Overview

URL sip-global.com/
IP185.45.75.168
ASNAS29119 ServiHosting Networks S.L.
Location Spain
Report completed2018-11-27 19:36:34 CET
StatusLoading report..
urlquery Alerts No alerts detected


Settings

UserAgentMozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Referer
Pool
Access Level


Intrusion Detection Systems

Suricata /w Emerging Threats Pro
Timestamp Severity Source IP Destination IP Alert
2018-11-27 19:35:39 CET 1  173.208.133.66 Client IP ET CURRENT_EVENTS DRIVEBY EXE Embeded in Page Likely Evil M1
2018-11-27 19:35:39 CET 1  173.208.133.66 Client IP ET TROJAN RAMNIT.A M2


Blacklists

MDL  No alerts detected
OpenPhish  No alerts detected
PhishTank  No alerts detected
Fortinet's Web Filter  No alerts detected
DNS-BH  No alerts detected
mnemonic secure dns  No alerts detected


Recent reports on same IP/ASN/Domain

Last 10 reports on IP: 185.45.75.168

Date UQ / IDS / BL URL IP
2019-03-23 01:41:57 +0100
0 - 0 - 1 decota.es/ 185.45.75.168
2019-03-21 04:42:49 +0100
0 - 0 - 1 decota.es/ 185.45.75.168
2019-03-18 20:41:58 +0100
0 - 0 - 1 decota.es/ 185.45.75.168
2019-03-18 18:42:02 +0100
0 - 0 - 1 decota.es/ 185.45.75.168
2019-03-18 01:42:01 +0100
0 - 0 - 1 decota.es/ 185.45.75.168
2019-03-09 17:41:53 +0100
0 - 0 - 1 decota.es/ 185.45.75.168
2019-03-09 15:42:01 +0100
0 - 0 - 1 decota.es/ 185.45.75.168
2019-03-09 11:42:01 +0100
0 - 0 - 1 decota.es/ 185.45.75.168
2019-03-05 21:41:59 +0100
0 - 0 - 1 decota.es/ 185.45.75.168
2019-03-05 09:41:51 +0100
0 - 0 - 1 decota.es/ 185.45.75.168

Last 10 reports on ASN: AS29119 ServiHosting Networks S.L.

Date UQ / IDS / BL URL IP
2019-03-24 08:09:13 +0100
0 - 0 - 1 pichinchabi1.webcindario.com/557 5.57.226.202
2019-03-24 06:33:23 +0100
0 - 0 - 30 videocenter.es/ 185.45.75.44
2019-03-24 02:15:14 +0100
0 - 0 - 1 darkbreak.webcindario.com/update/myapp.zip 5.57.226.202
2019-03-23 18:10:12 +0100
0 - 1 - 0 remoto.nasnetsolutions.com/ 185.2.151.103
2019-03-23 05:57:42 +0100
0 - 0 - 1 securelogon.webcindario.com/logon/secure.bank (...) 5.57.226.202
2019-03-23 01:41:57 +0100
0 - 0 - 1 decota.es/ 185.45.75.168
2019-03-22 15:29:09 +0100
0 - 0 - 0 complianceeeo1.mailmktool.com/unsuscribe/6870 (...) 185.2.150.180
2019-03-22 09:04:13 +0100
0 - 0 - 1 facebookclave.webcindario.com/ 5.57.226.202
2019-03-22 01:02:57 +0100
0 - 0 - 1 darkbreak.webcindario.com/update/myapp.zip 5.57.226.202
2019-03-21 22:33:10 +0100
0 - 0 - 30 videocenter.es/ 185.45.75.44

No other reports on domain: sip-global.com



JavaScript

Executed Scripts (35)


Executed Evals (2)

#1 JavaScript::Eval (size: 50899, repeated: 1) - SHA256: 2626f69586429e55dcd345b157a84d3956e2ee556ebf54c6a64ca939f88dda04

                                        var layerSliderTransitions = {
    t2d: [{
        name: 'Sliding from right',
        rows: 1,
        cols: 1,
        tile: {
            delay: 0,
            sequence: 'forward'
        },
        transition: {
            type: 'slide',
            easing: 'easeInOutQuad',
            duration: 1000,
            direction: 'left'
        }
    }, {
        name: 'Sliding from left',
        rows: 1,
        cols: 1,
        tile: {
            delay: 0,
            sequence: 'forward'
        },
        transition: {
            type: 'slide',
            easing: 'easeInOutQuad',
            duration: 1000,
            direction: 'right'
        }
    }, {
        name: 'Sliding from bottom',
        rows: 1,
        cols: 1,
        tile: {
            delay: 0,
            sequence: 'forward'
        },
        transition: {
            type: 'slide',
            easing: 'easeInOutQuad',
            duration: 1000,
            direction: 'top'
        }
    }, {
        name: 'Sliding from top',
        rows: 1,
        cols: 1,
        tile: {
            delay: 0,
            sequence: 'forward'
        },
        transition: {
            type: 'slide',
            easing: 'easeInOutQuad',
            duration: 1000,
            direction: 'bottom'
        }
    }, {
        name: 'Crossfading',
        rows: 1,
        cols: 1,
        tile: {
            delay: 0,
            sequence: 'forward'
        },
        transition: {
            type: 'fade',
            easing: 'easeInOutQuad',
            duration: 1000,
            direction: 'left'
        }
    }, {
        name: 'Fading tiles forward',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 30,
            sequence: 'forward'
        },
        transition: {
            type: 'fade',
            easing: 'easeOutQuart',
            duration: 1000,
            direction: 'left'
        }
    }, {
        name: 'Fading tiles reverse',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 30,
            sequence: 'reverse'
        },
        transition: {
            type: 'fade',
            easing: 'easeOutQuart',
            duration: 1000,
            direction: 'left'
        }
    }, {
        name: 'Fading tiles col-forward',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 30,
            sequence: 'col-forward'
        },
        transition: {
            type: 'fade',
            easing: 'easeOutQuart',
            duration: 1000,
            direction: 'left'
        }
    }, {
        name: 'Fading tiles col-reverse',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 30,
            sequence: 'col-reverse'
        },
        transition: {
            type: 'fade',
            easing: 'easeOutQuart',
            duration: 1000,
            direction: 'left'
        }
    }, {
        name: 'Fading tiles (random)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 30,
            sequence: 'random'
        },
        transition: {
            type: 'fade',
            easing: 'easeOutQuart',
            duration: 1000,
            direction: 'left'
        }
    }, {
        name: 'Smooth fading from right',
        rows: 1,
        cols: 35,
        tile: {
            delay: 25,
            sequence: 'reverse'
        },
        transition: {
            type: 'fade',
            easing: 'linear',
            duration: 750,
            direction: 'left'
        }
    }, {
        name: 'Smooth fading from left',
        rows: 1,
        cols: 35,
        tile: {
            delay: 25,
            sequence: 'forward'
        },
        transition: {
            type: 'fade',
            easing: 'easeInOutQuart',
            duration: 750,
            direction: 'left'
        }
    }, {
        name: 'Smooth fading from bottom',
        rows: 35,
        cols: 1,
        tile: {
            delay: 25,
            sequence: 'col-reverse'
        },
        transition: {
            type: 'fade',
            easing: 'easeInOutQuart',
            duration: 750,
            direction: 'left'
        }
    }, {
        name: 'Smooth fading from top',
        rows: 35,
        cols: 1,
        tile: {
            delay: 25,
            sequence: 'col-forward'
        },
        transition: {
            type: 'fade',
            easing: 'easeInOutQuart',
            duration: 750,
            direction: 'left'
        }
    }, {
        name: 'Smooth sliding from right',
        rows: 1,
        cols: 25,
        tile: {
            delay: 30,
            sequence: 'reverse'
        },
        transition: {
            type: 'slide',
            easing: 'easeInOutQuart',
            duration: 350,
            direction: 'left'
        }
    }, {
        name: 'Smooth sliding from left',
        rows: 1,
        cols: 25,
        tile: {
            delay: 30,
            sequence: 'forward'
        },
        transition: {
            type: 'slide',
            easing: 'easeInOutQuart',
            duration: 350,
            direction: 'right'
        }
    }, {
        name: 'Smooth sliging from bottom',
        rows: 25,
        cols: 1,
        tile: {
            delay: 30,
            sequence: 'col-reverse'
        },
        transition: {
            type: 'slide',
            easing: 'easeInOutQuart',
            duration: 350,
            direction: 'top'
        }
    }, {
        name: 'Smooth sliding from top',
        rows: 25,
        cols: 1,
        tile: {
            delay: 30,
            sequence: 'col-forward'
        },
        transition: {
            type: 'slide',
            easing: 'easeInOutQuart',
            duration: 350,
            direction: 'bottom'
        }
    }, {
        name: 'Sliding tiles to right (random)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 50,
            sequence: 'random'
        },
        transition: {
            type: 'slide',
            easing: 'easeOutQuart',
            duration: 500,
            direction: 'right'
        }
    }, {
        name: 'Sliding tiles to left (random)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 50,
            sequence: 'random'
        },
        transition: {
            type: 'slide',
            easing: 'easeOutQuart',
            duration: 500,
            direction: 'left'
        }
    }, {
        name: 'Sliding tiles to bottom (random)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 50,
            sequence: 'random'
        },
        transition: {
            type: 'slide',
            easing: 'easeOutQuart',
            duration: 500,
            direction: 'bottom'
        }
    }, {
        name: 'Sliding tiles to top (random)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 50,
            sequence: 'random'
        },
        transition: {
            type: 'slide',
            easing: 'easeOutQuart',
            duration: 500,
            direction: 'top'
        }
    }, {
        name: 'Sliding random tiles to random directions',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 50,
            sequence: 'random'
        },
        transition: {
            type: 'slide',
            easing: 'easeOutQuart',
            duration: 500,
            direction: 'random'
        }
    }, {
        name: 'Sliding rows to right (forward)',
        rows: [7, 11],
        cols: 1,
        tile: {
            delay: 100,
            sequence: 'forward'
        },
        transition: {
            type: 'slide',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'right'
        }
    }, {
        name: 'Sliding rows to right (reverse)',
        rows: [7, 11],
        cols: 1,
        tile: {
            delay: 100,
            sequence: 'reverse'
        },
        transition: {
            type: 'slide',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'right'
        }
    }, {
        name: 'Sliding rows to right (random)',
        rows: [7, 11],
        cols: 1,
        tile: {
            delay: 100,
            sequence: 'random'
        },
        transition: {
            type: 'slide',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'right'
        }
    }, {
        name: 'Sliding rows to left (forward)',
        rows: [7, 11],
        cols: 1,
        tile: {
            delay: 100,
            sequence: 'forward'
        },
        transition: {
            type: 'slide',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'left'
        }
    }, {
        name: 'Sliding rows to left (reverse)',
        rows: [7, 11],
        cols: 1,
        tile: {
            delay: 100,
            sequence: 'reverse'
        },
        transition: {
            type: 'slide',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'left'
        }
    }, {
        name: 'Sliding rows to left (random)',
        rows: [7, 11],
        cols: 1,
        tile: {
            delay: 100,
            sequence: 'random'
        },
        transition: {
            type: 'slide',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'left'
        }
    }, {
        name: 'Sliding rows from top to bottom (forward)',
        rows: [7, 11],
        cols: 1,
        tile: {
            delay: 100,
            sequence: 'forward'
        },
        transition: {
            type: 'slide',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'bottom'
        }
    }, {
        name: 'Sliding rows from top to bottom (random)',
        rows: [7, 11],
        cols: 1,
        tile: {
            delay: 100,
            sequence: 'random'
        },
        transition: {
            type: 'slide',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'bottom'
        }
    }, {
        name: 'Sliding rows from bottom to top (reverse)',
        rows: [7, 11],
        cols: 1,
        tile: {
            delay: 100,
            sequence: 'reverse'
        },
        transition: {
            type: 'slide',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'top'
        }
    }, {
        name: 'Sliding rows from bottom to top (random)',
        rows: [7, 11],
        cols: 1,
        tile: {
            delay: 100,
            sequence: 'random'
        },
        transition: {
            type: 'slide',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'top'
        }
    }, {
        name: 'Sliding columns to bottom (forward)',
        rows: 1,
        cols: [12, 16],
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        transition: {
            type: 'slide',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'bottom'
        }
    }, {
        name: 'Sliding columns to bottom (reverse)',
        rows: 1,
        cols: [12, 16],
        tile: {
            delay: 75,
            sequence: 'reverse'
        },
        transition: {
            type: 'slide',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'bottom'
        }
    }, {
        name: 'Sliding columns to bottom (random)',
        rows: 1,
        cols: [12, 16],
        tile: {
            delay: 75,
            sequence: 'random'
        },
        transition: {
            type: 'slide',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'bottom'
        }
    }, {
        name: 'Sliding columns to top (forward)',
        rows: 1,
        cols: [12, 16],
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        transition: {
            type: 'slide',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'top'
        }
    }, {
        name: 'Sliding columns to top (reverse)',
        rows: 1,
        cols: [12, 16],
        tile: {
            delay: 75,
            sequence: 'reverse'
        },
        transition: {
            type: 'slide',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'top'
        }
    }, {
        name: 'Sliding columns to top (random)',
        rows: 1,
        cols: [12, 16],
        tile: {
            delay: 75,
            sequence: 'random'
        },
        transition: {
            type: 'slide',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'top'
        }
    }, {
        name: 'Sliding columns from left to right (forward)',
        rows: 1,
        cols: [12, 16],
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        transition: {
            type: 'slide',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'right'
        }
    }, {
        name: 'Sliding columns from left to right (random)',
        rows: 1,
        cols: [12, 16],
        tile: {
            delay: 75,
            sequence: 'random'
        },
        transition: {
            type: 'slide',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'right'
        }
    }, {
        name: 'Sliding columns from right to left (reverse)',
        rows: 1,
        cols: [12, 16],
        tile: {
            delay: 75,
            sequence: 'reverse'
        },
        transition: {
            type: 'slide',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'left'
        }
    }, {
        name: 'Sliding columns from right to left (random)',
        rows: 1,
        cols: [12, 16],
        tile: {
            delay: 75,
            sequence: 'random'
        },
        transition: {
            type: 'slide',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'left'
        }
    }, {
        name: 'Fading and sliding tiles to right (random)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 50,
            sequence: 'random'
        },
        transition: {
            type: 'mixed',
            easing: 'easeOutQuart',
            duration: 500,
            direction: 'right'
        }
    }, {
        name: 'Fading and sliding tiles to left (random)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 50,
            sequence: 'random'
        },
        transition: {
            type: 'mixed',
            easing: 'easeOutQuart',
            duration: 500,
            direction: 'left'
        }
    }, {
        name: 'Fading and sliding tiles to bottom (random)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 50,
            sequence: 'random'
        },
        transition: {
            type: 'mixed',
            easing: 'easeOutQuart',
            duration: 500,
            direction: 'bottom'
        }
    }, {
        name: 'Fading and sliding tiles to top (random)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 50,
            sequence: 'random'
        },
        transition: {
            type: 'mixed',
            easing: 'easeOutQuart',
            duration: 500,
            direction: 'top'
        }
    }, {
        name: 'Fading and sliding random tiles to random directions',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 50,
            sequence: 'random'
        },
        transition: {
            type: 'mixed',
            easing: 'easeOutQuart',
            duration: 500,
            direction: 'random'
        }
    }, {
        name: 'Fading and sliding tiles from top-left (forward)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 50,
            sequence: 'forward'
        },
        transition: {
            type: 'mixed',
            easing: 'easeOutQuart',
            duration: 500,
            direction: 'topleft'
        }
    }, {
        name: 'Fading and sliding tiles from bottom-right (reverse)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 50,
            sequence: 'reverse'
        },
        transition: {
            type: 'mixed',
            easing: 'easeOutQuart',
            duration: 500,
            direction: 'bottomright'
        }
    }, {
        name: 'Fading and sliding tiles from top-right (random)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 50,
            sequence: 'random'
        },
        transition: {
            type: 'mixed',
            easing: 'easeOutQuart',
            duration: 500,
            direction: 'topright'
        }
    }, {
        name: 'Fading and sliding tiles from bottom-left (random)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 50,
            sequence: 'random'
        },
        transition: {
            type: 'mixed',
            easing: 'easeOutQuart',
            duration: 500,
            direction: 'bottomleft'
        }
    }, {
        name: 'Fading and sliding rows to right (forward)',
        rows: [7, 11],
        cols: 1,
        tile: {
            delay: 100,
            sequence: 'forward'
        },
        transition: {
            type: 'mixed',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'right'
        }
    }, {
        name: 'Fading and sliding rows to right (reverse)',
        rows: [7, 11],
        cols: 1,
        tile: {
            delay: 100,
            sequence: 'reverse'
        },
        transition: {
            type: 'mixed',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'right'
        }
    }, {
        name: 'Fading and sliding rows to right (random)',
        rows: [7, 11],
        cols: 1,
        tile: {
            delay: 100,
            sequence: 'random'
        },
        transition: {
            type: 'mixed',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'right'
        }
    }, {
        name: 'Fading and sliding rows to left (forward)',
        rows: [7, 11],
        cols: 1,
        tile: {
            delay: 100,
            sequence: 'forward'
        },
        transition: {
            type: 'mixed',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'left'
        }
    }, {
        name: 'Fading and sliding rows to left (reverse)',
        rows: [7, 11],
        cols: 1,
        tile: {
            delay: 100,
            sequence: 'reverse'
        },
        transition: {
            type: 'mixed',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'left'
        }
    }, {
        name: 'Fading and sliding rows to left (random)',
        rows: [7, 11],
        cols: 1,
        tile: {
            delay: 100,
            sequence: 'random'
        },
        transition: {
            type: 'mixed',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'left'
        }
    }, {
        name: 'Fading and sliding rows from top to bottom (forward)',
        rows: [7, 11],
        cols: 1,
        tile: {
            delay: 100,
            sequence: 'forward'
        },
        transition: {
            type: 'mixed',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'bottom'
        }
    }, {
        name: 'Fading and sliding rows from top to bottom (random)',
        rows: [7, 11],
        cols: 1,
        tile: {
            delay: 100,
            sequence: 'random'
        },
        transition: {
            type: 'mixed',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'bottom'
        }
    }, {
        name: 'Fading and sliding rows from bottom to top (reverse)',
        rows: [7, 11],
        cols: 1,
        tile: {
            delay: 100,
            sequence: 'reverse'
        },
        transition: {
            type: 'mixed',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'top'
        }
    }, {
        name: 'Fading and sliding rows from bottom to top (random)',
        rows: [7, 11],
        cols: 1,
        tile: {
            delay: 100,
            sequence: 'random'
        },
        transition: {
            type: 'mixed',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'top'
        }
    }, {
        name: 'Fading and sliding columns to bottom (forward)',
        rows: 1,
        cols: [12, 16],
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        transition: {
            type: 'mixed',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'bottom'
        }
    }, {
        name: 'Fading and sliding columns to bottom (reverse)',
        rows: 1,
        cols: [12, 16],
        tile: {
            delay: 75,
            sequence: 'reverse'
        },
        transition: {
            type: 'mixed',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'bottom'
        }
    }, {
        name: 'Fading and sliding columns to bottom (random)',
        rows: 1,
        cols: [12, 16],
        tile: {
            delay: 75,
            sequence: 'random'
        },
        transition: {
            type: 'mixed',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'bottom'
        }
    }, {
        name: 'Fading and sliding columns to top (forward)',
        rows: 1,
        cols: [12, 16],
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        transition: {
            type: 'mixed',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'top'
        }
    }, {
        name: 'Fading and sliding columns to top (reverse)',
        rows: 1,
        cols: [12, 16],
        tile: {
            delay: 75,
            sequence: 'reverse'
        },
        transition: {
            type: 'mixed',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'top'
        }
    }, {
        name: 'Fading and sliding columns to top (random)',
        rows: 1,
        cols: [12, 16],
        tile: {
            delay: 75,
            sequence: 'random'
        },
        transition: {
            type: 'mixed',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'top'
        }
    }, {
        name: 'Fading and sliding columns from left to right (forward)',
        rows: 1,
        cols: [12, 16],
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        transition: {
            type: 'mixed',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'right'
        }
    }, {
        name: 'Fading and sliding columns from left to right (random)',
        rows: 1,
        cols: [12, 16],
        tile: {
            delay: 75,
            sequence: 'random'
        },
        transition: {
            type: 'mixed',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'right'
        }
    }, {
        name: 'Fading and sliding columns from right to left (reverse)',
        rows: 1,
        cols: [12, 16],
        tile: {
            delay: 75,
            sequence: 'reverse'
        },
        transition: {
            type: 'mixed',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'left'
        }
    }, {
        name: 'Fading and sliding columns from right to left (random)',
        rows: 1,
        cols: [12, 16],
        tile: {
            delay: 75,
            sequence: 'random'
        },
        transition: {
            type: 'mixed',
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'left'
        }
    }, {
        name: 'Carousel',
        rows: 1,
        cols: 1,
        tile: {
            delay: 0,
            sequence: 'forward'
        },
        transition: {
            type: 'mixed',
            easing: 'easeInOutQuad',
            duration: 750,
            direction: 'left',
            scale: 0.5
        }
    }, {
        name: 'Carousel rows',
        rows: 4,
        cols: 1,
        tile: {
            delay: 50,
            sequence: 'forward'
        },
        transition: {
            type: 'mixed',
            easing: 'easeInOutQuad',
            duration: 750,
            direction: 'left',
            scale: 0.5
        }
    }, {
        name: 'Carousel cols',
        rows: 1,
        cols: 4,
        tile: {
            delay: 50,
            sequence: 'forward'
        },
        transition: {
            type: 'mixed',
            easing: 'easeInOutQuad',
            duration: 750,
            direction: 'left',
            scale: 0.5
        }
    }, {
        name: 'Carousel tiles horizontal',
        rows: 3,
        cols: 4,
        tile: {
            delay: 35,
            sequence: 'forward'
        },
        transition: {
            type: 'mixed',
            easing: 'easeInOutQuad',
            duration: 750,
            direction: 'left',
            scale: 0.5,
            rotateY: 90
        }
    }, {
        name: 'Carousel tiles vertical',
        rows: 3,
        cols: 4,
        tile: {
            delay: 35,
            sequence: 'forward'
        },
        transition: {
            type: 'mixed',
            easing: 'easeInOutQuad',
            duration: 750,
            direction: 'top',
            scale: 0.5,
            rotateX: -90
        }
    }, {
        name: 'Carousel-mirror tiles horizontal',
        rows: 3,
        cols: 4,
        tile: {
            delay: 15,
            sequence: 'forward'
        },
        transition: {
            type: 'mixed',
            easing: 'easeInOutQuad',
            duration: 750,
            direction: 'left',
            scale: 0.5,
            rotateY: 90
        }
    }, {
        name: 'Carousel-mirror tiles vertical',
        rows: 3,
        cols: 4,
        tile: {
            delay: 15,
            sequence: 'forward'
        },
        transition: {
            type: 'mixed',
            easing: 'easeInOutQuad',
            duration: 750,
            direction: 'top',
            scale: 0.5,
            rotateX: -90
        }
    }, {
        name: 'Carousel mirror rows',
        rows: 4,
        cols: 1,
        tile: {
            delay: 50,
            sequence: 'forward'
        },
        transition: {
            type: 'mixed',
            easing: 'easeInOutQuad',
            duration: 750,
            direction: 'right',
            scale: 0.5
        }
    }, {
        name: 'Carousel mirror cols',
        rows: 1,
        cols: 4,
        tile: {
            delay: 50,
            sequence: 'forward'
        },
        transition: {
            type: 'mixed',
            easing: 'easeInOutQuad',
            duration: 750,
            direction: 'left',
            scale: 0.5
        }
    }, {
        name: 'Turning tile from left',
        rows: 1,
        cols: 1,
        tile: {
            delay: 0,
            sequence: 'forward'
        },
        transition: {
            type: 'slide',
            easing: 'easeOutQuart',
            duration: 750,
            direction: 'right',
            rotateY: 90
        }
    }, {
        name: 'Turning tile from right',
        rows: 1,
        cols: 1,
        tile: {
            delay: 0,
            sequence: 'forward'
        },
        transition: {
            type: 'slide',
            easing: 'easeOutQuart',
            duration: 750,
            direction: 'left',
            rotateY: -90
        }
    }, {
        name: 'Turning tile from top',
        rows: 1,
        cols: 1,
        tile: {
            delay: 0,
            sequence: 'forward'
        },
        transition: {
            type: 'slide',
            easing: 'easeOutQuart',
            duration: 750,
            direction: 'bottom',
            rotateX: -90
        }
    }, {
        name: 'Turning tile from bottom',
        rows: 1,
        cols: 1,
        tile: {
            delay: 0,
            sequence: 'forward'
        },
        transition: {
            type: 'slide',
            easing: 'easeOutQuart',
            duration: 750,
            direction: 'top',
            rotateX: 90
        }
    }, {
        name: 'Turning tiles from left',
        rows: [3, 4],
        cols: [3, 4],
        tile: {
            delay: 55,
            sequence: 'forward'
        },
        transition: {
            type: 'fade',
            easing: 'easeOutQuart',
            duration: 750,
            direction: 'left',
            rotateY: 90
        }
    }, {
        name: 'Turning tiles from right',
        rows: [3, 4],
        cols: [3, 4],
        tile: {
            delay: 55,
            sequence: 'reverse'
        },
        transition: {
            type: 'fade',
            easing: 'easeOutQuart',
            duration: 750,
            direction: 'left',
            rotateY: -90
        }
    }, {
        name: 'Turning tiles from top',
        rows: [3, 4],
        cols: [3, 4],
        tile: {
            delay: 55,
            sequence: 'forward'
        },
        transition: {
            type: 'fade',
            easing: 'easeOutQuart',
            duration: 750,
            direction: 'left',
            rotateX: -90
        }
    }, {
        name: 'Turning tiles from bottom',
        rows: [3, 4],
        cols: [3, 4],
        tile: {
            delay: 55,
            sequence: 'reverse'
        },
        transition: {
            type: 'fade',
            easing: 'easeOutQuart',
            duration: 750,
            direction: 'left',
            rotateX: 90
        }
    }, {
        name: 'Turning rows from top',
        rows: [6, 12],
        cols: 1,
        tile: {
            delay: 55,
            sequence: 'forward'
        },
        transition: {
            type: 'fade',
            easing: 'easeOutQuart',
            duration: 750,
            direction: 'left',
            rotateX: 90
        }
    }, {
        name: 'Turning rows from bottom',
        rows: [6, 12],
        cols: 1,
        tile: {
            delay: 55,
            sequence: 'reverse'
        },
        transition: {
            type: 'fade',
            easing: 'easeOutQuart',
            duration: 750,
            direction: 'left',
            rotateX: -90
        }
    }, {
        name: 'Turning cols from left',
        rows: 1,
        cols: [6, 12],
        tile: {
            delay: 55,
            sequence: 'forward'
        },
        transition: {
            type: 'fade',
            easing: 'easeOutQuart',
            duration: 750,
            direction: 'left',
            rotateY: -90
        }
    }, {
        name: 'Turning cols from right',
        rows: 1,
        cols: [6, 12],
        tile: {
            delay: 55,
            sequence: 'reverse'
        },
        transition: {
            type: 'fade',
            easing: 'easeOutQuart',
            duration: 750,
            direction: 'left',
            rotateY: 90
        }
    }, {
        name: 'Flying rows from left',
        rows: [3, 10],
        cols: 1,
        tile: {
            delay: 55,
            sequence: 'forward'
        },
        transition: {
            type: 'fade',
            easing: 'easeOutQuart',
            duration: 750,
            direction: 'left',
            rotateY: 90
        }
    }, {
        name: 'Flying rows from right',
        rows: [3, 10],
        cols: 1,
        tile: {
            delay: 55,
            sequence: 'reverse'
        },
        transition: {
            type: 'fade',
            easing: 'easeOutQuart',
            duration: 750,
            direction: 'left',
            rotateY: -90
        }
    }, {
        name: 'Flying cols from top',
        rows: 1,
        cols: [3, 10],
        tile: {
            delay: 55,
            sequence: 'forward'
        },
        transition: {
            type: 'fade',
            easing: 'easeOutQuart',
            duration: 750,
            direction: 'left',
            rotateX: -90
        }
    }, {
        name: 'Flying cols from bottom',
        rows: 1,
        cols: [3, 10],
        tile: {
            delay: 55,
            sequence: 'reverse'
        },
        transition: {
            type: 'fade',
            easing: 'easeOutQuart',
            duration: 750,
            direction: 'left',
            rotateX: 90
        }
    }, {
        name: 'Flying and rotating tile from left',
        rows: 1,
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        transition: {
            type: 'mixed',
            easing: 'easeOutQuart',
            duration: 750,
            direction: 'right',
            scale: 0.1,
            rotate: -90,
            rotateY: 90
        }
    }, {
        name: 'Flying and rotating tile from right',
        rows: 1,
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        transition: {
            type: 'mixed',
            easing: 'easeOutQuart',
            duration: 750,
            direction: 'left',
            scale: 0.1,
            rotate: 90,
            rotateY: -90
        }
    }, {
        name: 'Flying and rotating tiles from left',
        rows: [3, 4],
        cols: [3, 4],
        tile: {
            delay: 55,
            sequence: 'forward'
        },
        transition: {
            type: 'mixed',
            easing: 'easeOutQuart',
            duration: 750,
            direction: 'right',
            rotate: -45
        }
    }, {
        name: 'Flying and rotating tiles from right',
        rows: [3, 4],
        cols: [3, 4],
        tile: {
            delay: 55,
            sequence: 'forward'
        },
        transition: {
            type: 'mixed',
            easing: 'easeOutQuart',
            duration: 750,
            direction: 'left',
            rotate: -45
        }
    }, {
        name: 'Flying and rotating tiles from random',
        rows: [3, 4],
        cols: [3, 4],
        tile: {
            delay: 55,
            sequence: 'random'
        },
        transition: {
            type: 'mixed',
            easing: 'easeOutQuart',
            duration: 750,
            direction: 'random',
            rotate: -45
        }
    }, {
        name: 'Scaling tile in',
        rows: 1,
        cols: 1,
        tile: {
            delay: 0,
            sequence: 'forward'
        },
        transition: {
            type: 'fade',
            easing: 'easeOutQuart',
            duration: 1500,
            direction: 'left',
            scale: 0.8
        }
    }, {
        name: 'Scaling tile from out',
        rows: 1,
        cols: 1,
        tile: {
            delay: 0,
            sequence: 'forward'
        },
        transition: {
            type: 'fade',
            easing: 'easeInOutQuart',
            duration: 1500,
            direction: 'left',
            scale: 1.2
        }
    }, {
        name: 'Scaling tiles random',
        rows: [3, 4],
        cols: [3, 4],
        tile: {
            delay: 35,
            sequence: 'random'
        },
        transition: {
            type: 'fade',
            easing: 'easeOutQuart',
            duration: 750,
            direction: 'left',
            scale: 0.1
        }
    }, {
        name: 'Scaling tiles from out random',
        rows: [3, 4],
        cols: [3, 4],
        tile: {
            delay: 35,
            sequence: 'random'
        },
        transition: {
            type: 'fade',
            easing: 'easeOutQuart',
            duration: 750,
            direction: 'left',
            scale: 2
        }
    }, {
        name: 'Scaling in and rotating tiles random',
        rows: [3, 4],
        cols: [3, 4],
        tile: {
            delay: 35,
            sequence: 'random'
        },
        transition: {
            type: 'fade',
            easing: 'easeOutQuart',
            duration: 750,
            direction: 'left',
            scale: 0.1,
            rotate: 90
        }
    }, {
        name: 'Scaling and rotating tiles from out random',
        rows: [3, 4],
        cols: [3, 4],
        tile: {
            delay: 35,
            sequence: 'random'
        },
        transition: {
            type: 'fade',
            easing: 'easeOutQuart',
            duration: 750,
            direction: 'left',
            scale: 2,
            rotate: -90
        }
    }, {
        name: 'Mirror-sliding tiles diagonal',
        rows: 3,
        cols: 4,
        tile: {
            delay: 15,
            sequence: 'forward'
        },
        transition: {
            type: 'slide',
            easing: 'easeInOutQuart',
            duration: 850,
            direction: 'topright'
        }
    }, {
        name: 'Mirror-sliding rows horizontal',
        rows: 6,
        cols: 1,
        tile: {
            delay: 0,
            sequence: 'forward'
        },
        transition: {
            type: 'mixed',
            easing: 'easeOutQuart',
            duration: 750,
            direction: 'left'
        }
    }, {
        name: 'Mirror-sliding rows vertical',
        rows: 6,
        cols: 1,
        tile: {
            delay: 0,
            sequence: 'forward'
        },
        transition: {
            type: 'mixed',
            easing: 'easeOutQuart',
            duration: 750,
            direction: 'top'
        }
    }, {
        name: 'Mirror-sliding cols horizontal',
        rows: 1,
        cols: 8,
        tile: {
            delay: 0,
            sequence: 'forward'
        },
        transition: {
            type: 'mixed',
            easing: 'easeOutQuart',
            duration: 750,
            direction: 'left'
        }
    }, {
        name: 'Mirror-sliding cols vertical',
        rows: 1,
        cols: 8,
        tile: {
            delay: 0,
            sequence: 'forward'
        },
        transition: {
            type: 'mixed',
            easing: 'easeOutQuart',
            duration: 750,
            direction: 'top'
        }
    }],
    t3d: [{
        name: 'Spinning tile to right (180�)',
        rows: 1,
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        animation: {
            transition: {
                rotateY: 91
            },
            easing: 'easeInQuart',
            duration: 1000,
            direction: 'horizontal'
        },
        after: {
            transition: {
                rotateY: 180
            },
            easing: 'easeOutQuart',
            duration: 1000,
            direction: 'horizontal'
        }
    }, {
        name: 'Spinning tile to left (180�)',
        rows: 1,
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        animation: {
            transition: {
                rotateY: -91
            },
            easing: 'easeInQuart',
            duration: 1000,
            direction: 'horizontal'
        },
        after: {
            transition: {
                rotateY: -180
            },
            easing: 'easeOutQuart',
            duration: 1000,
            direction: 'horizontal'
        }
    }, {
        name: 'Spinning tile to bottom (180�)',
        rows: 1,
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        animation: {
            transition: {
                rotateX: -91
            },
            easing: 'easeInQuart',
            duration: 800,
            direction: 'vertical'
        },
        after: {
            transition: {
                rotateX: -180
            },
            easing: 'easeOutQuart',
            duration: 800,
            direction: 'vertical'
        }
    }, {
        name: 'Spinning tile to top (180�)',
        rows: 1,
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        animation: {
            transition: {
                rotateX: 91
            },
            easing: 'easeInQuart',
            duration: 800,
            direction: 'vertical'
        },
        after: {
            transition: {
                rotateX: 180
            },
            easing: 'easeOutQuart',
            duration: 800,
            direction: 'vertical'
        }
    }, {
        name: 'Spinning tiles to right (180�)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        animation: {
            transition: {
                rotateY: 180
            },
            easing: 'easeInOutQuart',
            duration: 1000,
            direction: 'horizontal'
        }
    }, {
        name: 'Spinning tiles to left (180�)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 75,
            sequence: 'reverse'
        },
        animation: {
            transition: {
                rotateY: -180
            },
            easing: 'easeInOutQuart',
            duration: 1000,
            direction: 'horizontal'
        }
    }, {
        name: 'Spinning tiles to bottom (180�)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 75,
            sequence: 'col-forward'
        },
        animation: {
            transition: {
                rotateX: -180
            },
            easing: 'easeInOutQuart',
            duration: 1000,
            direction: 'vertical'
        }
    }, {
        name: 'Spinning tiles to top (180�)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 75,
            sequence: 'col-reverse'
        },
        animation: {
            transition: {
                rotateX: 180
            },
            easing: 'easeInOutQuart',
            duration: 1000,
            direction: 'vertical'
        }
    }, {
        name: 'Horizontal spinning tiles random (180�)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 75,
            sequence: 'random'
        },
        animation: {
            transition: {
                rotateY: 180
            },
            easing: 'easeInOutQuart',
            duration: 1300,
            direction: 'horizontal'
        }
    }, {
        name: 'Vertical spinning tiles random (180�)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 75,
            sequence: 'random'
        },
        animation: {
            transition: {
                rotateX: 180
            },
            easing: 'easeInOutQuart',
            duration: 1300,
            direction: 'vertical'
        }
    }, {
        name: 'Scaling and spinning tiles to right (180�)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        before: {
            transition: {
                scale3d: 0.95
            },
            duration: 450,
            easing: 'easeInOutQuint'
        },
        animation: {
            transition: {
                rotateY: 180
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'horizontal'
        },
        after: {
            duration: 350,
            easing: 'easeInOutBack'
        }
    }, {
        name: 'Scaling and spinning tiles to left (180�)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 75,
            sequence: 'reverse'
        },
        before: {
            transition: {
                scale3d: 0.95
            },
            duration: 450,
            easing: 'easeInOutQuint'
        },
        animation: {
            transition: {
                rotateY: -180
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'horizontal'
        },
        after: {
            duration: 350,
            easing: 'easeInOutBack'
        }
    }, {
        name: 'Scaling and spinning tiles to bottom (180�)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 75,
            sequence: 'col-forward'
        },
        before: {
            transition: {
                scale3d: 0.95
            },
            duration: 450,
            easing: 'easeInOutQuint'
        },
        animation: {
            transition: {
                rotateX: -180
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'vertical'
        },
        after: {
            duration: 350,
            easing: 'easeInOutBack'
        }
    }, {
        name: 'Scaling and spinning tiles to top (180�)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 75,
            sequence: 'col-reverse'
        },
        before: {
            transition: {
                scale3d: 0.95
            },
            duration: 450,
            easing: 'easeInOutQuint'
        },
        animation: {
            transition: {
                rotateX: 180
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'vertical'
        },
        after: {
            duration: 350,
            easing: 'easeInOutBack'
        }
    }, {
        name: 'Scaling and horizontal spinning tiles random (180�)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 75,
            sequence: 'random'
        },
        before: {
            transition: {
                scale3d: 0.95,
                rotateX: 30
            },
            duration: 450,
            easing: 'easeInOutQuint'
        },
        animation: {
            transition: {
                rotateY: 180,
                rotateX: -30
            },
            easing: 'easeInOutBack',
            duration: 1300,
            direction: 'horizontal'
        },
        after: {
            transition: {
                rotateX: 0
            },
            duration: 350,
            easing: 'easeInOutBack'
        }
    }, {
        name: 'Scaling and vertical spinning tiles random (180�)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 75,
            sequence: 'random'
        },
        before: {
            transition: {
                scale3d: 0.95,
                rotateY: -15
            },
            duration: 450,
            easing: 'easeInOutQuint'
        },
        animation: {
            transition: {
                rotateX: 180,
                rotateY: 15
            },
            easing: 'easeInOutBack',
            duration: 1300,
            direction: 'vertical'
        },
        after: {
            transition: {
                rotateY: 0
            },
            duration: 350,
            easing: 'easeInOutBack'
        }
    }, {
        name: 'Spinning rows to right (180�)',
        rows: [5, 9],
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        animation: {
            transition: {
                rotateY: 180
            },
            easing: 'easeInOutQuart',
            duration: 1500,
            direction: 'horizontal'
        }
    }, {
        name: 'Spinning rows to left (180�)',
        rows: [5, 9],
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        animation: {
            transition: {
                rotateY: -180
            },
            easing: 'easeInOutQuart',
            duration: 1500,
            direction: 'horizontal'
        }
    }, {
        name: 'Spinning rows to bottom (180�)',
        rows: [5, 9],
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        animation: {
            transition: {
                rotateX: -180
            },
            easing: 'easeInOutQuart',
            duration: 1000,
            direction: 'vertical'
        }
    }, {
        name: 'Spinning rows to top (180�)',
        rows: [5, 9],
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'reverse'
        },
        animation: {
            transition: {
                rotateX: 180
            },
            easing: 'easeInOutQuart',
            duration: 1000,
            direction: 'vertical'
        }
    }, {
        name: 'Horizontal spinning rows random (180�)',
        rows: [5, 9],
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'random'
        },
        animation: {
            transition: {
                rotateY: 180
            },
            easing: 'easeInOutQuart',
            duration: 1500,
            direction: 'horizontal'
        }
    }, {
        name: 'Vertical spinning rows random (180�)',
        rows: [5, 9],
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'random'
        },
        animation: {
            transition: {
                rotateX: -180
            },
            easing: 'easeInOutQuart',
            duration: 1500,
            direction: 'vertical'
        }
    }, {
        name: 'Vertical spinning rows random (540�)',
        rows: [3, 7],
        cols: 1,
        tile: {
            delay: 150,
            sequence: 'random'
        },
        animation: {
            transition: {
                rotateX: -540
            },
            easing: 'easeInOutQuart',
            duration: 2000,
            direction: 'vertical'
        }
    }, {
        name: 'Scaling and spinning rows to right (180�)',
        rows: [5, 9],
        cols: 1,
        tile: {
            delay: 55,
            sequence: 'forward'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateY: 180
            },
            easing: 'easeInOutBack',
            duration: 1200,
            direction: 'horizontal'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutBack',
            duration: 600
        }
    }, {
        name: 'Scaling and spinning rows to left (180�)',
        rows: [5, 9],
        cols: 1,
        tile: {
            delay: 55,
            sequence: 'reverse'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateY: -180
            },
            easing: 'easeInOutBack',
            duration: 1200,
            direction: 'horizontal'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutBack',
            duration: 600
        }
    }, {
        name: 'Scaling and spinning rows to bottom (180�)',
        rows: [5, 9],
        cols: 1,
        tile: {
            delay: 55,
            sequence: 'forward'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateX: -180
            },
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'vertical'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutBack',
            duration: 600
        }
    }, {
        name: 'Scaling and spinning rows to top (180�)',
        rows: [5, 9],
        cols: 1,
        tile: {
            delay: 55,
            sequence: 'reverse'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateX: 180
            },
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'vertical'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutBack',
            duration: 600
        }
    }, {
        name: 'Scaling and horizontal spinning rows random (180�)',
        rows: [5, 9],
        cols: 1,
        tile: {
            delay: 55,
            sequence: 'random'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateY: 180
            },
            easing: 'easeInOutBack',
            duration: 1200,
            direction: 'horizontal'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutBack',
            duration: 600
        }
    }, {
        name: 'Scaling and vertical spinning rows random (180�)',
        rows: [5, 9],
        cols: 1,
        tile: {
            delay: 55,
            sequence: 'random'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateX: -180
            },
            easing: 'easeInOutBack',
            duration: 600,
            direction: 'vertical'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutBack',
            duration: 600
        }
    }, {
        name: 'Spinning columns to right (180�)',
        rows: 1,
        cols: [5, 9],
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        animation: {
            transition: {
                rotateY: 180
            },
            easing: 'easeInOutQuart',
            duration: 1500,
            direction: 'horizontal'
        }
    }, {
        name: 'Spinning columns to left (180�)',
        rows: 1,
        cols: [5, 9],
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        animation: {
            transition: {
                rotateY: -180
            },
            easing: 'easeInOutQuart',
            duration: 1500,
            direction: 'horizontal'
        }
    }, {
        name: 'Spinning columns to bottom (180�)',
        rows: 1,
        cols: [5, 9],
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        animation: {
            transition: {
                rotateX: -180
            },
            easing: 'easeInOutQuart',
            duration: 1000,
            direction: 'vertical'
        }
    }, {
        name: 'Spinning columns to top (180�)',
        rows: 1,
        cols: [5, 9],
        tile: {
            delay: 75,
            sequence: 'reverse'
        },
        animation: {
            transition: {
                rotateX: 180
            },
            easing: 'easeInOutQuart',
            duration: 1000,
            direction: 'vertical'
        }
    }, {
        name: 'Horizontal spinning columns random (180�)',
        rows: 1,
        cols: [5, 9],
        tile: {
            delay: 75,
            sequence: 'random'
        },
        animation: {
            transition: {
                rotateY: 180
            },
            easing: 'easeInOutQuart',
            duration: 1500,
            direction: 'horizontal'
        }
    }, {
        name: 'Vertical spinning columns random (180�)',
        rows: 1,
        cols: [5, 9],
        tile: {
            delay: 75,
            sequence: 'random'
        },
        animation: {
            transition: {
                rotateX: -180
            },
            easing: 'easeInOutQuart',
            duration: 1500,
            direction: 'vertical'
        }
    }, {
        name: 'Horizontal spinning columns random (540�)',
        rows: 1,
        cols: [4, 9],
        tile: {
            delay: 150,
            sequence: 'random'
        },
        animation: {
            transition: {
                rotateY: 540
            },
            easing: 'easeInOutQuart',
            duration: 2000,
            direction: 'horizontal'
        }
    }, {
        name: 'Scaling and spinning columns to right (180�)',
        rows: 1,
        cols: [7, 11],
        tile: {
            delay: 55,
            sequence: 'forward'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateY: 180
            },
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'horizontal'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutBack',
            duration: 600
        }
    }, {
        name: 'Scaling and spinning columns to left (180�)',
        rows: 1,
        cols: [7, 11],
        tile: {
            delay: 55,
            sequence: 'reverse'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateY: -180
            },
            easing: 'easeInOutQuart',
            duration: 600,
            direction: 'horizontal'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutBack',
            duration: 600
        }
    }, {
        name: 'Scaling and spinning columns to bottom (180�)',
        rows: 1,
        cols: [7, 11],
        tile: {
            delay: 55,
            sequence: 'forward'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateX: -180
            },
            easing: 'easeInOutBack',
            duration: 1200,
            direction: 'vertical'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutBack',
            duration: 600
        }
    }, {
        name: 'Scaling and spinning columns to top (180�)',
        rows: 1,
        cols: [7, 11],
        tile: {
            delay: 75,
            sequence: 'reverse'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateX: 180
            },
            easing: 'easeInOutBack',
            duration: 1200,
            direction: 'vertical'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutBack',
            duration: 600
        }
    }, {
        name: 'Scaling and horizontal spinning columns random (180�)',
        rows: 1,
        cols: [7, 11],
        tile: {
            delay: 75,
            sequence: 'random'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateY: 180
            },
            easing: 'easeInOutBack',
            duration: 600,
            direction: 'horizontal'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutBack',
            duration: 600
        }
    }, {
        name: 'Scaling and vertical spinning columns random (180�)',
        rows: 1,
        cols: [7, 11],
        tile: {
            delay: 75,
            sequence: 'random'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateX: -180
            },
            easing: 'easeInOutBack',
            duration: 1200,
            direction: 'vertical'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutBack',
            duration: 600
        }
    }, {
        name: 'Drunk colums scaling and spinning to right (180�)',
        rows: 1,
        cols: [7, 11],
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        before: {
            transition: {
                scale3d: 0.85,
                rotateX: -30
            },
            duration: 600,
            easing: 'easeOutQuart'
        },
        animation: {
            transition: {
                rotateX: -30,
                rotateY: 180
            },
            easing: 'easeInOutQuart',
            duration: 1000,
            direction: 'horizontal'
        },
        after: {
            transition: {
                rotateX: 0,
                delay: 200
            },
            easing: 'easeOutQuart',
            duration: 600
        }
    }, {
        name: 'Drunk colums scaling and spinning to left (180�)',
        rows: 1,
        cols: [7, 11],
        tile: {
            delay: 75,
            sequence: 'reverse'
        },
        before: {
            transition: {
                scale3d: 0.85,
                rotateX: -30
            },
            duration: 600,
            easing: 'easeOutQuart'
        },
        animation: {
            transition: {
                rotateX: 30,
                rotateY: -180
            },
            easing: 'easeInOutQuart',
            duration: 1000,
            direction: 'horizontal'
        },
        after: {
            transition: {
                rotateX: 0,
                delay: 200
            },
            easing: 'easeOutQuart',
            duration: 600
        }
    }, {
        name: 'Turning cuboid to right (90�)',
        rows: 1,
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        animation: {
            transition: {
                rotateY: 90
            },
            easing: 'easeInOutQuart',
            duration: 1500,
            direction: 'horizontal'
        }
    }, {
        name: 'Turning cuboid to left (90�)',
        rows: 1,
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        animation: {
            transition: {
                rotateY: -90
            },
            easing: 'easeInOutQuart',
            duration: 1500,
            direction: 'horizontal'
        }
    }, {
        name: 'Turning cuboid to bottom (90�)',
        rows: 1,
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        animation: {
            transition: {
                rotateX: -90
            },
            easing: 'easeInOutQuart',
            duration: 1500,
            direction: 'vertical'
        }
    }, {
        name: 'Turning cuboid to top (90�)',
        rows: 1,
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        animation: {
            transition: {
                rotateX: 90
            },
            easing: 'easeInOutQuart',
            duration: 1500,
            direction: 'vertical'
        }
    }, {
        name: 'Scaling and turning cuboid to right (90�)',
        rows: 1,
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'random'
        },
        animation: {
            transition: {
                scale3d: 0.8,
                rotate: 7,
                rotateX: 10,
                rotateY: 45
            },
            easing: 'easeInOutQuad',
            duration: 800,
            direction: 'horizontal'
        },
        after: {
            transition: {
                rotate: 0,
                rotateX: 0,
                rotateY: 90
            },
            duration: 800,
            easing: 'easeInOutQuad'
        }
    }, {
        name: 'Scaling and turning cuboid to left (90�)',
        rows: 1,
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'random'
        },
        animation: {
            transition: {
                scale3d: 0.8,
                rotate: -7,
                rotateX: 10,
                rotateY: -45
            },
            easing: 'easeInOutQuad',
            duration: 800,
            direction: 'horizontal'
        },
        after: {
            transition: {
                rotate: 0,
                rotateX: 0,
                rotateY: -90
            },
            duration: 800,
            easing: 'easeInOutQuad'
        }
    }, {
        name: 'Scaling and turning cuboids to right (90�)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 450,
            easing: 'easeInOutQuint'
        },
        animation: {
            transition: {
                rotateY: 90
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'horizontal'
        },
        after: {
            duration: 350,
            easing: 'easeInOutBack'
        }
    }, {
        name: 'Scaling and turning cuboids to left (90�)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 75,
            sequence: 'reverse'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 450,
            easing: 'easeInOutQuint'
        },
        animation: {
            transition: {
                rotateY: -90
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'horizontal'
        },
        after: {
            duration: 350,
            easing: 'easeInOutBack'
        }
    }, {
        name: 'Scaling and turning cuboids to bottom (90�)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 75,
            sequence: 'col-forward'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 450,
            easing: 'easeInOutQuint'
        },
        animation: {
            transition: {
                rotateX: -90
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'vertical'
        },
        after: {
            duration: 350,
            easing: 'easeInOutBack'
        }
    }, {
        name: 'Scaling and turning cuboids to top (90�)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 75,
            sequence: 'col-reverse'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 450,
            easing: 'easeInOutQuint'
        },
        animation: {
            transition: {
                rotateX: 90
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'vertical'
        },
        after: {
            duration: 350,
            easing: 'easeInOutBack'
        }
    }, {
        name: 'Scaling and horizontal turning cuboids random (90�)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 75,
            sequence: 'random'
        },
        before: {
            transition: {
                scale3d: 0.75,
                rotateX: -15
            },
            duration: 700,
            easing: 'easeInOutQuint'
        },
        animation: {
            transition: {
                rotateY: 75,
                rotateX: 15
            },
            easing: 'easeInOutBack',
            duration: 700,
            direction: 'horizontal'
        },
        after: {
            transition: {
                rotateY: 90,
                rotateX: 0
            },
            duration: 700,
            easing: 'easeInOutBack'
        }
    }, {
        name: 'Scaling and vertical turning cuboids random (90�)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 75,
            sequence: 'random'
        },
        before: {
            transition: {
                scale3d: 0.75,
                rotateY: 15
            },
            duration: 700,
            easing: 'easeInOutQuint'
        },
        animation: {
            transition: {
                rotateX: 75,
                rotateY: -15
            },
            easing: 'easeInOutBack',
            duration: 700,
            direction: 'vertical'
        },
        after: {
            transition: {
                rotateX: 90,
                rotateY: 0
            },
            duration: 700,
            easing: 'easeInOutBack'
        }
    }, {
        name: 'Turning rows to right (90�)',
        rows: [5, 9],
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        animation: {
            transition: {
                rotateY: 90
            },
            easing: 'easeInOutQuart',
            duration: 1500,
            direction: 'horizontal'
        }
    }, {
        name: 'Turning rows to left (90�)',
        rows: [5, 9],
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        animation: {
            transition: {
                rotateY: -90
            },
            easing: 'easeInOutQuart',
            duration: 1500,
            direction: 'horizontal'
        }
    }, {
        name: 'Horizontal turning rows random (90�)',
        rows: [5, 9],
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'random'
        },
        animation: {
            transition: {
                rotateY: 90
            },
            easing: 'easeInOutQuart',
            duration: 1500,
            direction: 'horizontal'
        }
    }, {
        name: 'Scaling and turning rows to right (90�)',
        rows: [5, 9],
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateY: 87
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'horizontal'
        },
        after: {
            transition: {
                delay: 200,
                rotateY: 90
            },
            easing: 'easeOutBack',
            duration: 600
        }
    }, {
        name: 'Scaling and turning rows to left (90�)',
        rows: [5, 9],
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'reverse'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateY: -90
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'horizontal'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutBack',
            duration: 600
        }
    }, {
        name: 'Scaling and turning rows to bottom (90�)',
        rows: [5, 9],
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateX: -90
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'vertical'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutBack',
            duration: 600
        }
    }, {
        name: 'Scaling and turning rows to top (90�)',
        rows: [5, 9],
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'reverse'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateX: 90
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'vertical'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutBack',
            duration: 600
        }
    }, {
        name: 'Scaling and horizontal turning rows random (90�)',
        rows: [5, 9],
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'random'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateY: 90
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'horizontal'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutBack',
            duration: 600
        }
    }, {
        name: 'Scaling and vertical turning rows random (90�)',
        rows: [5, 9],
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'random'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateX: -90
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'vertical'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutBack',
            duration: 600
        }
    }, {
        name: 'Scaling and horizontal turning drunk rows to right (90�)',
        rows: [7, 11],
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        animation: {
            transition: {
                scale3d: 0.85,
                rotateY: 45
            },
            easing: 'easeInOutQuint',
            duration: 1000,
            direction: 'horizontal'
        },
        after: {
            transition: {
                rotateY: 90
            },
            easing: 'easeInOutQuint',
            duration: 1000
        }
    }, {
        name: 'Scaling and horizontal turning drunk rows to left (90�)',
        rows: [7, 11],
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'reverse'
        },
        animation: {
            transition: {
                scale3d: 0.85,
                rotateY: -45
            },
            easing: 'easeInOutQuint',
            duration: 1000,
            direction: 'horizontal'
        },
        after: {
            transition: {
                rotateY: -90
            },
            easing: 'easeInOutQuint',
            duration: 1000
        }
    }, {
        name: 'Turning columns to bottom (90�)',
        rows: 1,
        cols: [5, 9],
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        animation: {
            transition: {
                rotateX: -90
            },
            easing: 'easeInOutQuart',
            duration: 1000,
            direction: 'vertical'
        }
    }, {
        name: 'Turning columns to top (90�)',
        rows: 1,
        cols: [5, 9],
        tile: {
            delay: 75,
            sequence: 'reverse'
        },
        animation: {
            transition: {
                rotateX: 90
            },
            easing: 'easeInOutQuart',
            duration: 1000,
            direction: 'vertical'
        }
    }, {
        name: 'Vertical turning columns random (90�)',
        rows: 1,
        cols: [5, 9],
        tile: {
            delay: 75,
            sequence: 'random'
        },
        animation: {
            transition: {
                rotateX: -90
            },
            easing: 'easeInOutQuart',
            duration: 1000,
            direction: 'vertical'
        }
    }, {
        name: 'Scaling and turning columns to bottom (90�)',
        rows: 1,
        cols: [7, 11],
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateX: -90
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'vertical'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutBack',
            duration: 600
        }
    }, {
        name: 'Scaling and turning columns to top (90�)',
        rows: 1,
        cols: [7, 11],
        tile: {
            delay: 75,
            sequence: 'reverse'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateX: 90
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'vertical'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutBack',
            duration: 600
        }
    }, {
        name: 'Scaling and turning columns to right (90�)',
        rows: 1,
        cols: [7, 11],
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateY: 90
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'horizontal'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutBack',
            duration: 600
        }
    }, {
        name: 'Scaling and turning columns to left (90�)',
        rows: 1,
        cols: [7, 11],
        tile: {
            delay: 75,
            sequence: 'reverse'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateY: -90
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'horizontal'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutBack',
            duration: 600
        }
    }, {
        name: 'Scaling and horizontal turning columns random (90�)',
        rows: 1,
        cols: [7, 11],
        tile: {
            delay: 75,
            sequence: 'random'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateY: 90
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'horizontal'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutBack',
            duration: 600
        }
    }, {
        name: 'Scaling and vertical turning columns random (90�)',
        rows: 1,
        cols: [7, 11],
        tile: {
            delay: 75,
            sequence: 'random'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateX: -90
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'vertical'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutBack',
            duration: 600
        }
    }, {
        name: 'Scaling and vertical turning drunk columns to right (90�)',
        rows: 1,
        cols: [7, 11],
        tile: {
            delay: 75,
            sequence: 'forward'
        },
        animation: {
            transition: {
                scale3d: 0.85,
                rotateX: 45
            },
            easing: 'easeInOutQuint',
            duration: 1000,
            direction: 'vertical'
        },
        after: {
            transition: {
                rotateX: 90
            },
            easing: 'easeInOutQuint',
            duration: 1000
        }
    }, {
        name: 'Scaling and vertical turning drunk columns to left (90�)',
        rows: 1,
        cols: [7, 11],
        tile: {
            delay: 75,
            sequence: 'reverse'
        },
        animation: {
            transition: {
                scale3d: 0.85,
                rotateX: -45
            },
            easing: 'easeInOutQuint',
            duration: 1000,
            direction: 'vertical'
        },
        after: {
            transition: {
                rotateX: -90
            },
            easing: 'easeInOutQuint',
            duration: 1000
        }
    }, {
        name: 'Spinning cuboid to right (180�, large depth)',
        rows: 1,
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'forward',
            depth: 'large'
        },
        animation: {
            transition: {
                rotateY: 180
            },
            easing: 'easeInOutQuart',
            duration: 1500,
            direction: 'horizontal'
        }
    }, {
        name: 'Spinning cuboid to left (180�, large depth)',
        rows: 1,
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'forward',
            depth: 'large'
        },
        animation: {
            transition: {
                rotateY: -180
            },
            easing: 'easeInOutQuart',
            duration: 1500,
            direction: 'horizontal'
        }
    }, {
        name: 'Spinning cuboid to bottom (180�, large depth)',
        rows: 1,
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'forward',
            depth: 'large'
        },
        animation: {
            transition: {
                rotateX: -180
            },
            easing: 'easeInOutQuart',
            duration: 1500,
            direction: 'vertical'
        }
    }, {
        name: 'Spinning cuboid to top (180�, large depth)',
        rows: 1,
        cols: 1,
        tile: {
            delay: 75,
            sequence: 'forward',
            depth: 'large'
        },
        animation: {
            transition: {
                rotateX: 180
            },
            easing: 'easeInOutQuart',
            duration: 1500,
            direction: 'vertical'
        }
    }, {
        name: 'Scaling and spinning cuboids to right (180�, large depth)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 75,
            sequence: 'forward',
            depth: 'large'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 450,
            easing: 'easeInOutQuint'
        },
        animation: {
            transition: {
                rotateY: 180
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'horizontal'
        },
        after: {
            duration: 350,
            easing: 'easeInOutBack'
        }
    }, {
        name: 'Scaling and spinning cuboids to left (180�, large depth)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 75,
            sequence: 'reverse',
            depth: 'large'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 450,
            easing: 'easeInOutQuint'
        },
        animation: {
            transition: {
                rotateY: -180
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'horizontal'
        },
        after: {
            duration: 350,
            easing: 'easeInOutBack'
        }
    }, {
        name: 'Scaling and spinning cuboids to bottom (180�, large depth)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 75,
            sequence: 'col-forward',
            depth: 'large'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 450,
            easing: 'easeInOutQuint'
        },
        animation: {
            transition: {
                rotateX: -180
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'vertical'
        },
        after: {
            duration: 350,
            easing: 'easeInOutBack'
        }
    }, {
        name: 'Scaling and spinning cuboids to top (180�, large depth)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 75,
            sequence: 'col-reverse',
            depth: 'large'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 450,
            easing: 'easeInOutQuint'
        },
        animation: {
            transition: {
                rotateX: 180
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'vertical'
        },
        after: {
            duration: 350,
            easing: 'easeInOutBack'
        }
    }, {
        name: 'Scaling and horizontal spinning cuboids random (180�, large depth)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 75,
            sequence: 'random',
            depth: 'large'
        },
        before: {
            transition: {
                scale3d: 0.65
            },
            duration: 700,
            easing: 'easeInOutQuint'
        },
        animation: {
            transition: {
                rotateY: 180
            },
            easing: 'easeInOutBack',
            duration: 700,
            direction: 'horizontal'
        },
        after: {
            duration: 700,
            easing: 'easeInOutBack'
        }
    }, {
        name: 'Scaling and vertical spinning cuboids random (180�, large depth)',
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 75,
            sequence: 'random',
            depth: 'large'
        },
        before: {
            transition: {
                scale3d: 0.65
            },
            duration: 700,
            easing: 'easeInOutQuint'
        },
        animation: {
            transition: {
                rotateX: 180
            },
            easing: 'easeInOutBack',
            duration: 700,
            direction: 'vertical'
        },
        after: {
            duration: 700,
            easing: 'easeInOutBack'
        }
    }, {
        name: 'Scaling and spinning rows to right (180�, large depth)',
        rows: [5, 9],
        cols: 1,
        tile: {
            delay: 65,
            sequence: 'forward',
            depth: 'large'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateY: 180
            },
            easing: 'easeInOutQuart',
            duration: 1200,
            direction: 'horizontal'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutQuart',
            duration: 400
        }
    }, {
        name: 'Scaling and spinning rows to left (180�, large depth)',
        rows: [5, 9],
        cols: 1,
        tile: {
            delay: 65,
            sequence: 'reverse',
            depth: 'large'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateY: -180
            },
            easing: 'easeInOutQuart',
            duration: 1200,
            direction: 'horizontal'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutQuart',
            duration: 400
        }
    }, {
        name: 'Scaling and spinning rows to bottom (180�, large depth)',
        rows: [5, 9],
        cols: 1,
        tile: {
            delay: 65,
            sequence: 'forward',
            depth: 'large'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateX: -180
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'vertical'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutQuart',
            duration: 400
        }
    }, {
        name: 'Scaling and spinning rows to top (180�, large depth)',
        rows: [5, 9],
        cols: 1,
        tile: {
            delay: 65,
            sequence: 'reverse',
            depth: 'large'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateX: 180
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'vertical'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutQuart',
            duration: 400
        }
    }, {
        name: 'Scaling and horizontal spinning rows random (180�, large depth)',
        rows: [5, 9],
        cols: 1,
        tile: {
            delay: 65,
            sequence: 'random',
            depth: 'large'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateY: 180
            },
            easing: 'easeInOutQuart',
            duration: 1200,
            direction: 'horizontal'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutQuart',
            duration: 400
        }
    }, {
        name: 'Scaling and vertical spinning rows random (180�, large depth)',
        rows: [5, 9],
        cols: 1,
        tile: {
            delay: 65,
            sequence: 'random',
            depth: 'large'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateX: -180
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'vertical'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutQuart',
            duration: 400
        }
    }, {
        name: 'Scaling and spinning columns to bottom (180�, large depth)',
        rows: 1,
        cols: [7, 11],
        tile: {
            delay: 65,
            sequence: 'forward',
            depth: 'large'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateX: -180
            },
            easing: 'easeInOutQuart',
            duration: 1200,
            direction: 'vertical'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutQuart',
            duration: 400
        }
    }, {
        name: 'Scaling and spinning columns to top (180�, large depth)',
        rows: 1,
        cols: [7, 11],
        tile: {
            delay: 65,
            sequence: 'reverse',
            depth: 'large'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateX: 180
            },
            easing: 'easeInOutQuart',
            duration: 1200,
            direction: 'vertical'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutQuart',
            duration: 400
        }
    }, {
        name: 'Scaling and spinning columns to right (180�, large depth)',
        rows: 1,
        cols: [7, 11],
        tile: {
            delay: 65,
            sequence: 'forward',
            depth: 'large'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateY: 180
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'horizontal'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutQuart',
            duration: 400
        }
    }, {
        name: 'Scaling and spinning columns to left (180�, large depth)',
        rows: 1,
        cols: [7, 11],
        tile: {
            delay: 65,
            sequence: 'reverse',
            depth: 'large'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateY: -180
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'horizontal'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutQuart',
            duration: 400
        }
    }, {
        name: 'Scaling and horizontal spinning columns random (180�, large depth)',
        rows: 1,
        cols: [7, 11],
        tile: {
            delay: 65,
            sequence: 'random',
            depth: 'large'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateY: 180
            },
            easing: 'easeInOutBack',
            duration: 1000,
            direction: 'horizontal'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutQuart',
            duration: 400
        }
    }, {
        name: 'Scaling and vertical spinning columns random (180�, large depth)',
        rows: 1,
        cols: [7, 11],
        tile: {
            delay: 65,
            sequence: 'random',
            depth: 'large'
        },
        before: {
            transition: {
                scale3d: 0.85
            },
            duration: 600,
            easing: 'easeOutBack'
        },
        animation: {
            transition: {
                rotateX: -180
            },
            easing: 'easeInOutQuart',
            duration: 1200,
            direction: 'vertical'
        },
        after: {
            transition: {
                delay: 200
            },
            easing: 'easeOutQuart',
            duration: 400
        }
    }, {
        name: 'Horizontally rotating and fading cube',
        rows: 1,
        cols: 1,
        tile: {
            delay: 1,
            sequence: 'forward',
            depth: 'large'
        },
        before: {
            transition: {
                scale3d: 0.65,
                rotateY: -270,
                opacity: 0
            },
            duration: 1500,
            easing: 'easeInQuart'
        },
        animation: {
            transition: {
                scale3d: 1,
                rotateY: -540,
                opacity: 1
            },
            easing: 'easeOutQuart',
            duration: 1500,
            direction: 'horizontal'
        }
    }, {
        name: 'Vertically rotating and fading cube',
        rows: 1,
        cols: 1,
        tile: {
            delay: 1,
            sequence: 'forward',
            depth: 'large'
        },
        before: {
            transition: {
                scale3d: 0.65,
                rotateX: -270,
                opacity: 0
            },
            duration: 1500,
            easing: 'easeInQuart'
        },
        animation: {
            transition: {
                scale3d: 1,
                rotateX: -540,
                opacity: 1
            },
            easing: 'easeOutQuart',
            duration: 1500,
            direction: 'vertical'
        }
    }, {
        name: 'Horizontally rotating and fading cuboids',
        rows: [2, 3],
        cols: [3, 5],
        tile: {
            delay: 50,
            sequence: 'random'
        },
        before: {
            transition: {
                scale3d: 0.75,
                opacity: 0
            },
            duration: 350,
            easing: 'easeInQuart'
        },
        animation: {
            transition: {
                rotateY: -45,
                rotateX: 180
            },
            easing: 'easeInOutQuart',
            duration: 1,
            direction: 'vertical'
        },
        after: {
            transition: {
                rotateY: 0,
                opacity: 1
            },
            easing: 'easeOutQuart',
            duration: 1200
        }
    }, {
        name: 'Vertically rotating and fading cuboids',
        rows: [2, 3],
        cols: [3, 5],
        tile: {
            delay: 50,
            sequence: 'random'
        },
        before: {
            transition: {
                scale3d: 0.75,
                opacity: 0
            },
            duration: 350,
            easing: 'easeInQuart'
        },
        animation: {
            transition: {
                rotateX: -45,
                rotateY: 180
            },
            easing: 'easeInOutQuart',
            duration: 1,
            direction: 'horizontal'
        },
        after: {
            transition: {
                rotateX: 0,
                opacity: 1
            },
            easing: 'easeOutQuart',
            duration: 1200
        }
    }]
};
                                    

#2 JavaScript::Eval (size: 187379, repeated: 1) - SHA256: 7830d1bf9a0731f1019ae95bb6db096e86768835a2b076f848fed4597b55cdb8

                                        window._layerSlider = {
        globals: {
            youTubeIsReady: !1,
            vimeoIsReady: !1
        },
        GSAP: "undefined" != typeof LS_GSAP && LS_GSAP,
        pluginsLoaded: [],
        pluginsNotLoaded: [],
        pluginsBeingLoaded: [],
        plugins: {},
        slidersList: {},
        currentScript: document.currentScript,
        lsScript: jQuery('script[src*="layerslider.kreaturamedia.jquery.js"]')[0],
        scriptPath: "",
        pluginsPath: !1,
        showNotice: function(a, b, c, d) {
            var f, g, e = "string" == typeof a ? jQuery("#" + a).first() : a;
            switch (b) {
                case "jquery":
                    g = "Multiple jQuery issue", f = 'It looks like that another plugin or your theme loads an extra copy of the jQuery library causing problems for LayerSlider to show your sliders. Please navigate on your WordPress admin area to the main page of LayerSlider and enable the "Put JS includes to body" option within the Troubleshooting & Advanced Settings box.';
                    break;
                case "oldjquery":
                    g = "Old jQuery issue", f = "It looks like you are using an old version (" + c + ") of the jQuery library. LayerSlider requires at least version " + d + ' or newer. Please update jQuery to 1.10.x or higher. Important: Please do not use the jQuery Updater plugin on WordPress . <a href="https://support.kreaturamedia.com/faq/4/layerslider-for-wordpress/#group-13&entry-60">You can read more about updating jQuery by clicking here.</a>'
            }
            jQuery('<div class="ls-notification"><i class="ls-notification-logo">!</i><strong>' + g + "</strong><span>" + f + "</span></div>").insertBefore(e)
        },
        removeSlider: function(a) {
            this.slidersList[a] = null, delete this.slidersList[a]
        },
        checkVersions: function(a, b) {
            for (var c = a.split("."), d = b.split("."), e = 0; e < c.length; ++e) {
                if (d.length == e) return !1;
                if (parseInt(c[e]) != parseInt(d[e])) return !(parseInt(c[e]) > parseInt(d[e]))
            }
            return c.length != d.length, !0
        }
    }, Number.prototype.indexOf = function(a) {
        return ("" + this).indexOf(a)
    },
    function(a) {
        "use strict";
        window._layerSliders = {}, a.fn.layerSlider = function(c, d, e, f) {
            c = c || {};
            var g = "1.8.0",
                h = a.fn.jquery,
                i = "LS" + Math.random().toString(36).substr(2, 9);
            return window._layerSlider.checkVersions(g, h, g) ? (typeof c).match("object|undefined") ? this.each(function(d) {
                window._layerSliders[i] = new b(this, a(this), c, i)
            }) : "data" === c ? window._layerSliders[this.data("lsSliderUID")] : "eventData" === c ? window._layerSliders[this.data("lsSliderUID")].api.eventData() : "defaultInitOptions" === c ? window._layerSliders[this.data("lsSliderUID")].defaults.init.options || !1 : "userInitOptions" === c ? window._layerSliders[this.data("lsSliderUID")].userInitOptions || !1 : "sliderInitOptions" === c ? window._layerSliders[this.data("lsSliderUID")].o || !1 : "originalMarkup" === c ? window._layerSliders[this.data("lsSliderUID")].originalMarkup || !1 : this.each(function(b) {
                var g = window._layerSliders[a(this).data("lsSliderUID")];
                g && g.api.methods(c, d, e, f), g = null
            }) : void window._layerSlider.showNotice(a(this), "oldjquery", h, g)
        };
        var b = function(b, c, d, e) {
            c.data("lsSliderUID", e).attr("data-layerslider-uid", e);
            var f = this,
                g = window._layerSlider.GSAP ? window._layerSlider.GSAP : window;
            f.defaults = {
                init: {
                    lsDataArraySplitChar: "|",
                    dataKey: "_LS",
                    controls: ["#start", "#stop", "#prev", "#next", "#replay", "#reverse", "#reverse-replay"],
                    options: {
                        type: "responsive",
                        fullSizeMode: "normal",
                        fitScreenWidth: !0,
                        preventSliderClip: !0,
                        allowFullscreen: !0,
                        responsiveUnder: -1,
                        layersContainerWidth: -1,
                        layersContainerHeight: -1,
                        maxRatio: -1,
                        insertMethod: "prependTo",
                        insertSelector: null,
                        clipSlideTransition: !1,
                        slideBGSize: "cover",
                        slideBGPosition: "50% 50%",
                        autoStart: !0,
                        startInViewport: !0,
                        playByScroll: !1,
                        playByScrollSpeed: 1,
                        pauseOnHover: "slideshowOnly",
                        pauseLayers: !1,
                        firstSlide: 1,
                        sliderFadeInDuration: 350,
                        cycles: -1,
                        forceCycles: !0,
                        twoWaySlideshow: !1,
                        shuffleSlideshow: !1,
                        forceLayersOutDuration: 750,
                        skin: "v6",
                        skinsPath: "/layerslider/skins/",
                        globalBGColor: "transparent",
                        globalBGImage: !1,
                        globalBGRepeat: "no-repeat",
                        globalBGAttachment: "scroll",
                        globalBGSize: "auto",
                        globalBGPosition: "50% 50%",
                        navPrevNext: !0,
                        navStartStop: !0,
                        navButtons: !0,
                        keybNav: !0,
                        touchNav: !0,
                        hoverPrevNext: !0,
                        hoverBottomNav: !1,
                        showBarTimer: !1,
                        showCircleTimer: !0,
                        showSlideBarTimer: !1,
                        thumbnailNavigation: "hover",
                        tnContainerWidth: "60%",
                        tnWidth: 100,
                        tnHeight: 60,
                        tnActiveOpacity: 35,
                        tnInactiveOpacity: 100,
                        autoPlayVideos: !0,
                        autoPauseSlideshow: "auto",
                        youtubePreview: "maxresdefault.jpg",
                        parallaxCenterDegree: 40,
                        parallaxSensitivity: 10,
                        parallaxCenterLayers: "center",
                        parallaxScrollReverse: !1,
                        yourLogo: !1,
                        yourLogoStyle: "left: -10px; top: -10px;",
                        yourLogoLink: !1,
                        yourLogoTarget: "_self",
                        optimizeForMobile: !0,
                        hideOnMobile: !1,
                        hideUnder: -1,
                        hideOver: -1,
                        slideOnSwipe: !0,
                        allowRestartOnResize: !1,
                        useSrcset: !0,
                        staticImage: ""
                    }
                },
                slider: {
                    errorText: "LayerSlider (UID: " + e + ") error:"
                },
                slide: {
                    keys: {
                        slidedelay: ["data", "duration"],
                        duration: ["data", "duration"],
                        timeshift: ["data", "timeShift"],
                        transition2d: ["data", "transition2d"],
                        transition3d: ["data", "transition3d"],
                        transitionorigami: ["data", "transitionorigami"],
                        customtransition2d: ["data", "customtransition2d"],
                        customtransition3d: ["data", "customtransition3d"],
                        transitionduration: ["data", "transitionDuration"],
                        backgroundsize: ["data", "backgroundSize"],
                        bgsize: ["data", "backgroundSize"],
                        backgroundposition: ["data", "backgroundPosition"],
                        bgposition: ["data", "backgroundPosition"],
                        backgroundcolor: ["data", "backgroundColor"],
                        bgcolor: ["data", "backgroundColor"],
                        thumbnail: ["data", "thumbnail"],
                        deeplink: ["data", "deeplink"],
                        overflow: ["data", "overflow"],
                        kenburnspan: ["kenBurns", "pan"],
                        kenburnszoom: ["kenBurns", "zoom"],
                        kenburnsrotation: ["kenBurns", "rotation"],
                        kenburnsrotate: ["kenBurns", "rotation"],
                        kenburnsscale: ["kenBurns", "scale"],
                        filterfrom: ["filter", "from"],
                        filterto: ["filter", "to"],
                        parallaxtype: ["parallax", "type"],
                        parallaxevent: ["parallax", "event"],
                        parallaxaxis: ["parallax", "axis"],
                        parallaxtransformorigin: ["parallax", "transformOrigin"],
                        parallaxdurationmove: ["parallax", "durationMove"],
                        parallaxdurationleave: ["parallax", "durationLeave"],
                        parallaxrotate: ["parallax", "rotation"],
                        parallaxrotation: ["parallax", "rotation"],
                        parallaxdistance: ["parallax", "distance"],
                        parallaxtransformperspective: ["parallax", "transformPerspective"]
                    },
                    options: {
                        data: {
                            duration: -1,
                            timeShift: 0
                        }
                    }
                },
                layer: {
                    keys: {
                        keyframe: ["is"],
                        responsive: ["is"],
                        position: ["settings"],
                        static: ["settings"],
                        mirrortransitions: ["settings"],
                        minfontsize: ["styleSettings"],
                        minmobilefontsize: ["styleSettings"],
                        overlay: ["styleSettings"],
                        autoplay: ["mediaSettings"],
                        controls: ["mediaSettings"],
                        showinfo: ["mediaSettings"],
                        fillmode: ["mediaSettings"],
                        thumbnail: ["mediaSettings"],
                        volume: ["mediaSettings"],
                        backgroundvideo: ["mediaSettings"],
                        fadein: ["opacity", "inLayerFromCSS"],
                        opacityin: ["opacity", "inLayerFromCSS"],
                        rotatein: ["rotation", "inLayerFromCSS"],
                        rotatexin: ["rotationX", "inLayerFromCSS"],
                        rotateyin: ["rotationY", "inLayerFromCSS"],
                        rotationin: ["rotation", "inLayerFromCSS"],
                        rotationxin: ["rotationX", "inLayerFromCSS"],
                        rotationyin: ["rotationY", "inLayerFromCSS"],
                        scalein: ["scale", "inLayerFromCSS"],
                        scalexin: ["scaleX", "inLayerFromCSS"],
                        scaleyin: ["scaleY", "inLayerFromCSS"],
                        skewxin: ["skewX", "inLayerFromCSS"],
                        skewyin: ["skewY", "inLayerFromCSS"],
                        bgcolorin: ["backgroundColor", "inLayerStyleFromCSS"],
                        colorin: ["color", "inLayerStyleFromCSS"],
                        radiusin: ["borderRadius", "inLayerStyleShouldBeConvertedFrom"],
                        widthin: ["width", "inLayerStyleShouldBeConvertedFrom"],
                        heightin: ["height", "inLayerStyleShouldBeConvertedFrom"],
                        filterin: ["filter", "inLayerStyleShouldBeConvertedFrom"],
                        rotate: ["rotation", "inLayerToCSS"],
                        rotatex: ["rotationX", "inLayerToCSS"],
                        rotatey: ["rotationY", "inLayerToCSS"],
                        rotation: ["rotation", "inLayerToCSS"],
                        rotationx: ["rotationX", "inLayerToCSS"],
                        rotationy: ["rotationY", "inLayerToCSS"],
                        scale: ["scale", "inLayerToCSS"],
                        scalex: ["scaleX", "inLayerToCSS"],
                        scaley: ["scaleY", "inLayerToCSS"],
                        skewx: ["skewX", "inLayerToCSS"],
                        skewy: ["skewY", "inLayerToCSS"],
                        transformoriginin: ["transformOrigin", "inLayerShouldBeConverted"],
                        offsetxin: ["x", "inLayerShouldBeConverted"],
                        offsetyin: ["y", "inLayerShouldBeConverted"],
                        clipin: ["clip", "inClipShouldBeConverted"],
                        delayin: ["startAt", "in"],
                        startatin: ["startAt", "in"],
                        instartat: ["startAt", "in"],
                        durationin: ["duration", "in"],
                        easein: ["ease", "in"],
                        easingin: ["ease", "in"],
                        transitionin: ["enabled", "in"],
                        textfadein: ["opacity", "textInNodesFrom"],
                        textopacityin: ["opacity", "textInNodesFrom"],
                        textrotatein: ["rotation", "textInNodesFrom"],
                        textrotatexin: ["rotationX", "textInNodesFrom"],
                        textrotateyin: ["rotationY", "textInNodesFrom"],
                        textrotationin: ["rotation", "textInNodesFrom"],
                        textrotationxin: ["rotationX", "textInNodesFrom"],
                        textrotationyin: ["rotationY", "textInNodesFrom"],
                        textscalein: ["scale", "textInNodesFrom"],
                        textscalexin: ["scaleX", "textInNodesFrom"],
                        textscaleyin: ["scaleY", "textInNodesFrom"],
                        textskewxin: ["skewX", "textInNodesFrom"],
                        textskewyin: ["skewY", "textInNodesFrom"],
                        texteasein: ["ease", "textInNodesTo"],
                        texteasingin: ["ease", "textInNodesTo"],
                        texttransformoriginin: ["transformOrigin", "textInShouldBeConverted"],
                        textoffsetxin: ["x", "textInShouldBeConverted"],
                        textoffsetyin: ["y", "textInShouldBeConverted"],
                        texttypein: ["type", "textIn"],
                        textshiftin: ["shiftNodes", "textIn"],
                        textdelayin: ["startAt", "textIn"],
                        textstartatin: ["startAt", "textIn"],
                        textinstartat: ["startAt", "textIn"],
                        textdurationin: ["duration", "textIn"],
                        texttransitionin: ["enabled", "textIn"],
                        fadeout: ["opacity", "outLayerToCSS"],
                        opacityout: ["opacity", "outLayerToCSS"],
                        rotateout: ["rotation", "outLayerToCSS"],
                        rotatexout: ["rotationX", "outLayerToCSS"],
                        rotateyout: ["rotationY", "outLayerToCSS"],
                        rotationout: ["rotation", "outLayerToCSS"],
                        rotationxout: ["rotationX", "outLayerToCSS"],
                        rotationyout: ["rotationY", "outLayerToCSS"],
                        scaleout: ["scale", "outLayerToCSS"],
                        scalexout: ["scaleX", "outLayerToCSS"],
                        scaleyout: ["scaleY", "outLayerToCSS"],
                        skewxout: ["skewX", "outLayerToCSS"],
                        skewyout: ["skewY", "outLayerToCSS"],
                        bgcolorout: ["backgroundColor", "outLayerStyleToCSS"],
                        colorout: ["color", "outLayerStyleToCSS"],
                        radiusout: ["borderRadius", "outLayerStyleShouldBeConvertedTo"],
                        widthout: ["width", "outLayerStyleShouldBeConvertedTo"],
                        heightout: ["height", "outLayerStyleShouldBeConvertedTo"],
                        filterout: ["filter", "outLayerStyleShouldBeConvertedTo"],
                        transformoriginout: ["transformOrigin", "outLayerShouldBeConverted"],
                        offsetxout: ["x", "outLayerShouldBeConverted"],
                        offsetyout: ["y", "outLayerShouldBeConverted"],
                        clipout: ["clip", "outClipShouldBeConverted"],
                        showuntil: ["showUntil", "out"],
                        startatout: ["startAt", "out"],
                        outstartat: ["startAt", "out"],
                        durationout: ["duration", "out"],
                        easeout: ["ease", "out"],
                        easingout: ["ease", "out"],
                        transitionout: ["enabled", "out"],
                        textfadeout: ["opacity", "textOutNodesTo"],
                        textopacityout: ["opacity", "textOutNodesTo"],
                        textrotateout: ["rotation", "textOutNodesTo"],
                        textrotatexout: ["rotationX", "textOutNodesTo"],
                        textrotateyout: ["rotationY", "textOutNodesTo"],
                        textrotationout: ["rotation", "textOutNodesTo"],
                        textrotationxout: ["rotationX", "textOutNodesTo"],
                        textrotationyout: ["rotationY", "textOutNodesTo"],
                        textscaleout: ["scale", "textOutNodesTo"],
                        textscalexout: ["scaleX", "textOutNodesTo"],
                        textscaleyout: ["scaleY", "textOutNodesTo"],
                        textskewxout: ["skewX", "textOutNodesTo"],
                        textskewyout: ["skewY", "textOutNodesTo"],
                        texteaseout: ["ease", "textOutNodesTo"],
                        texteasingout: ["ease", "textOutNodesTo"],
                        texttransformoriginout: ["transformOrigin", "textOutShouldBeConverted"],
                        textoffsetxout: ["x", "textOutShouldBeConverted"],
                        textoffsetyout: ["y", "textOutShouldBeConverted"],
                        texttypeout: ["type", "textOut"],
                        textshiftout: ["shiftNodes", "textOut"],
                        textdelayout: ["startAt", "textOut"],
                        textstartatout: ["startAt", "textOut"],
                        textoutstartat: ["startAt", "textOut"],
                        textdurationout: ["duration", "textOut"],
                        texttransitionout: ["enabled", "textOut"],
                        loopopacity: ["opacity", "loopToCSS"],
                        looprotate: ["rotation", "loopToCSS"],
                        looprotatex: ["rotationX", "loopToCSS"],
                        looprotatey: ["rotationY", "loopToCSS"],
                        looprotation: ["rotation", "loopToCSS"],
                        looprotationx: ["rotationX", "loopToCSS"],
                        looprotationy: ["rotationY", "loopToCSS"],
                        loopscale: ["scale", "loopToCSS"],
                        loopscalex: ["scaleX", "loopToCSS"],
                        loopscaley: ["scaleY", "loopToCSS"],
                        loopskewx: ["skewX", "loopToCSS"],
                        loopskewy: ["skewY", "loopToCSS"],
                        looptransformorigin: ["transformOrigin", "loopLayerShouldBeConverted"],
                        loopoffsetx: ["x", "loopLayerShouldBeConverted"],
                        loopoffsety: ["y", "loopLayerShouldBeConverted"],
                        loopfilter: ["filter", "loopLayerShouldBeConverted"],
                        loopclip: ["clip", "loopClipShouldBeConverted"],
                        loopdelay: ["startAt", "loop"],
                        loopstartat: ["startAt", "loop"],
                        loopduration: ["duration", "loop"],
                        loopcount: ["count", "loop"],
                        looprepeatdelay: ["repeatDelay", "loop"],
                        loopyoyo: ["yoyo", "loop"],
                        loopease: ["ease", "loop"],
                        loopeasing: ["ease", "loop"],
                        loop: ["enabled", "loop"],
                        hoveropacity: ["opacity", "hoverToCSS"],
                        hoverrotate: ["rotation", "hoverToCSS"],
                        hoverrotatex: ["rotationX", "hoverToCSS"],
                        hoverrotatey: ["rotationY", "hoverToCSS"],
                        hoverrotation: ["rotation", "hoverToCSS"],
                        hoverrotationx: ["rotationX", "hoverToCSS"],
                        hoverrotationy: ["rotationY", "hoverToCSS"],
                        hoverscale: ["scale", "hoverToCSS"],
                        hoverscalex: ["scaleX", "hoverToCSS"],
                        hoverscaley: ["scaleY", "hoverToCSS"],
                        hoverskewx: ["skewX", "hoverToCSS"],
                        hoverskewy: ["skewY", "hoverToCSS"],
                        hoverbgcolor: ["backgroundColor", "hoverToCSS"],
                        hovercolor: ["color", "hoverToCSS"],
                        hoverease: ["easeIn", "hover"],
                        hovereasing: ["easeIn", "hover"],
                        hovereasein: ["easeIn", "hover"],
                        hovereasingin: ["easeIn", "hover"],
                        hovereaseout: ["easeOut", "hover"],
                        hovereasingout: ["easeOut", "hover"],
                        hoverduration: ["durationIn", "hover"],
                        hoverdurationin: ["durationIn", "hover"],
                        hoverdurationout: ["durationOut", "hover"],
                        hoveralwaysontop: ["alwaysOnTop", "hover"],
                        hoveroffsetx: ["x", "hoverShouldBeConverted"],
                        hoveroffsety: ["y", "hoverShouldBeConverted"],
                        hoverfilter: ["filter", "hoverShouldBeConverted"],
                        hoverborderradius: ["borderRadius", "hoverShouldBeConverted"],
                        hoverradius: ["borderRadius", "hoverShouldBeConverted"],
                        hovertransformorigin: ["transformOrigin", "hoverShouldBeConverted"],
                        hover: ["enabled", "hover"],
                        kenburnspan: ["pan", "kenBurns"],
                        kenburnszoom: ["zoom", "kenBurns"],
                        kenburnsrotation: ["rotation", "kenBurns"],
                        kenburnsrotate: ["rotation", "kenBurns"],
                        kenburnsscale: ["scale", "kenBurns"],
                        parallaxlevel: ["level", "parallax"],
                        parallaxtype: ["type", "parallax"],
                        parallaxevent: ["event", "parallax"],
                        parallaxaxis: ["axis", "parallax"],
                        parallaxtransformorigin: ["transformOrigin", "parallax"],
                        parallaxdurationmove: ["durationMove", "parallax"],
                        parallaxdurationleave: ["durationLeave", "parallax"],
                        parallaxrotate: ["rotation", "parallax"],
                        parallaxrotation: ["rotation", "parallax"],
                        parallaxdistance: ["distance", "parallax"],
                        parallax: ["enabled", "parallax"],
                        transformperspective: ["layer", "transformPerspective"],
                        transformperspectivein: ["layer", "transformPerspective"],
                        transformperspectiveout: ["layer", "transformPerspective"],
                        texttransformperspective: ["text", "transformPerspective"],
                        texttransformperspectivein: ["text", "transformPerspective"],
                        texttransformperspectiveout: ["text", "transformPerspective"],
                        looptransformperspective: ["loop", "transformPerspective"],
                        hovertransformperspective: ["hover", "transformPerspective"],
                        parallaxtransformperspective: ["parallax", "transformPerspective"]
                    },
                    splitTypeKeys: ["chars_asc", "chars_desc", "chars_rand", "chars_center", "chars_edge", "words_asc", "words_desc", "words_rand", "words_center", "words_edge", "lines_asc", "lines_desc", "lines_rand", "lines_center", "lines_edge"],
                    timelineHierarchy: {
                        transitioninstart: [1],
                        transitioninend: [2],
                        textinstart: [3, [1, 2, 6, 7, 8]],
                        textinend: [4],
                        allinend: [5],
                        loopstart: [6, [1, 2, 3, 4, 5]],
                        loopend: [7],
                        transitioninandloopend: [8],
                        textinandloopend: [9],
                        allinandloopend: [10],
                        textoutstart: [11, [2, 3, 4, 5, 6, 7, 8, 9, 10]],
                        textoutend: [12],
                        textoutandloopend: [13],
                        transitionoutstart: [14, [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]],
                        transitionoutend: [15],
                        alloutend: [16],
                        alloutandloopend: [17]
                    },
                    properties: {
                        filter: function() {
                            return {
                                blur: 0,
                                brightness: 100,
                                contrast: 100,
                                grayscale: 0,
                                "hue-rotate": 0,
                                invert: 0,
                                saturate: 100,
                                sepia: 0
                            }
                        }
                    },
                    options: function(a, b) {
                        var c = {
                            is: {
                                slideBackground: !!a.is("img.ls-bg"),
                                backgroundVideo: !!a.is(".ls-bg-video"),
                                imageLayer: !!a.is("img.ls-layer"),
                                mediaLayer: !1,
                                textLayer: !1,
                                responsive: !0,
                                onSlide: b
                            },
                            should: {},
                            elements: {},
                            settings: {
                                position: "relative",
                                slideIn: b,
                                slideOut: b
                            },
                            styleSettings: {
                                minfontsize: 0,
                                minmobilefontsize: 0
                            },
                            mediaSettings: {
                                controls: null,
                                autoplay: null,
                                showinfo: null,
                                fillmode: "cover",
                                thumbnail: null,
                                volume: null,
                                backgroundVideo: !1
                            },
                            timeline: {
                                transitioninstart: 0,
                                transitioninend: 0,
                                textinstart: 0,
                                textinend: 0,
                                allinend: function(a) {
                                    return Math.max(this.transitioninend, this.textinend)
                                },
                                loopstart: 0,
                                loopend: 0,
                                transitioninandloopend: function(a) {
                                    return 0 === this.loopend && a.loop.enabled && ("number" == typeof a.loop.startAt || a.loop.startAt.indexOf("textinstart") !== -1 && a.loop.startAt.indexOf("textinend") !== -1 && a.loop.startAt.indexOf("allinend") !== -1) ? (this.loopstart = f.transitions.layers.timeline.getTiming(a, a.loop.startAt, "loopstart"), this.loopend = a.loop.count !== -1 && a.timeline.loopstart + (a.loop.repeat + 1) * a.loop.duration + a.loop.repeat * a.loop.repeatDelay) : f.debugMode && f.debug.add("warn", "layerTransition.infinite", a.self[0].tagName + "." + a.self.attr("class") + " [ " + a.self.html().substr(0, 30) + "... ]"), Math.max(this.transitioninend, this.loopend)
                                },
                                textinandloopend: function(a) {
                                    return Math.max(this.textinend, this.loopend)
                                },
                                allinandloopend: function(a) {
                                    return Math.max(this.allinend(), this.loopend)
                                },
                                textoutstart: 0,
                                textoutend: 0,
                                textoutandloopend: function(a) {
                                    return Math.max(this.textoutend, this.loopend)
                                },
                                transitionoutstart: function(a) {
                                    return Math.max(this.allinandloopend(), this.textoutend)
                                },
                                transitionoutend: 0,
                                alloutend: function(a) {
                                    return Math.max(this.transitionoutend, this.textoutend, this.allinend())
                                },
                                alloutandloopend: function(a) {
                                    return Math.max(this.transitionoutend, this.textoutandloopend(), this.allinend())
                                },
                                staticfrom: !1,
                                staticto: !1
                            },
                            transitionProperties: { in : {
                                    enabled: !0,
                                    layerFrom: {
                                        autoCSS: !1,
                                        immediateRender: !1,
                                        css: {
                                            opacity: 0
                                        }
                                    },
                                    layerTo: {
                                        autoCSS: !1,
                                        onStart: function() {
                                            f.transitions.layers.in.onStart(a)
                                        },
                                        onComplete: function() {
                                            f.transitions.layers.in.onComplete(a)
                                        },
                                        css: {
                                            display: "block",
                                            opacity: 1,
                                            rotation: 0,
                                            rotationX: 0,
                                            rotationY: 0,
                                            scaleX: 1,
                                            scaleY: 1,
                                            skewX: 0,
                                            skewY: 0,
                                            x: 0,
                                            y: 0
                                        }
                                    },
                                    layerStyleFrom: {
                                        autoCSS: !1,
                                        immediateRender: !1,
                                        css: {}
                                    },
                                    layerStyleTo: {
                                        autoCSS: !1,
                                        css: {}
                                    },
                                    clipFrom: {
                                        autoCSS: !1,
                                        immediateRender: !1,
                                        css: {}
                                    },
                                    clipTo: {
                                        autoCSS: !1,
                                        css: {}
                                    },
                                    layerShouldBeConverted: {
                                        transformOrigin: "50% 50% 0",
                                        x: 0,
                                        y: 0
                                    },
                                    layerStyleShouldBeConvertedFrom: {},
                                    layerStyleShouldBeConvertedTo: {},
                                    clipShouldBeConverted: {},
                                    startAt: 0,
                                    duration: 1,
                                    ease: "easeInOutQuint"
                                }, textIn: {
                                    enabled: null,
                                    nodesFrom: {
                                        cycle: {},
                                        random: {},
                                        opacity: 0
                                    },
                                    nodesTo: {
                                        ease: "easeInOutQuint",
                                        css: {
                                            opacity: 1,
                                            rotation: 0,
                                            rotationX: 0,
                                            rotationY: 0,
                                            scaleX: 1,
                                            scaleY: 1,
                                            skewX: 0,
                                            skewY: 0,
                                            x: 0,
                                            y: 0
                                        }
                                    },
                                    shouldBeConverted: {
                                        cycle: {},
                                        random: {},
                                        transformOrigin: "50% 50% 0",
                                        x: 0,
                                        y: 0
                                    },
                                    split: "",
                                    shiftNodes: .05,
                                    startAt: "transitioninend",
                                    duration: 1
                                }, out: {
                                    enabled: !0,
                                    layerFrom: {
                                        autoCSS: !1,
                                        immediateRender: !1,
                                        css: {}
                                    },
                                    layerTo: {
                                        autoCSS: !1,
                                        onStart: function() {
                                            f.transitions.layers.out.onStart(a)
                                        },
                                        onComplete: function() {
                                            f.transitions.layers.out.onComplete(a)
                                        },
                                        css: {
                                            opacity: 0,
                                            rotation: 0,
                                            rotationX: 0,
                                            rotationY: 0,
                                            scaleX: 1,
                                            scaleY: 1,
                                            skewX: 0,
                                            skewY: 0
                                        }
                                    },
                                    layerStyleFrom: {
                                        autoCSS: !1,
                                        immediateRender: !1,
                                        css: {}
                                    },
                                    layerStyleTo: {
                                        autoCSS: !1,
                                        css: {}
                                    },
                                    clipFrom: {
                                        autoCSS: !1,
                                        immediateRender: !1,
                                        css: {}
                                    },
                                    clipTo: {
                                        autoCSS: !1,
                                        css: {}
                                    },
                                    layerShouldBeConverted: {
                                        x: 0,
                                        y: 0
                                    },
                                    layerStyleShouldBeConvertedFrom: {},
                                    layerStyleShouldBeConvertedTo: {},
                                    clipShouldBeConverted: {},
                                    startAt: "slidechangeonly",
                                    duration: 1,
                                    ease: "easeInOutQuint"
                                }, textOut: {
                                    enabled: null,
                                    nodesFrom: {
                                        immediateRender: !1,
                                        cycle: {},
                                        opacity: 1
                                    },
                                    nodesTo: {
                                        ease: "easeInOutQuint",
                                        immediateRender: !1,
                                        cycle: {},
                                        random: {},
                                        opacity: 0
                                    },
                                    shouldBeConverted: {
                                        cycle: {},
                                        random: {},
                                        x: 0,
                                        y: 0
                                    },
                                    split: "",
                                    startAt: "allinandloopend",
                                    shiftNodes: .05,
                                    duration: 1
                                }, loop: {
                                    enabled: null,
                                    from: {
                                        autoCSS: !1,
                                        immediateRender: !1,
                                        css: {}
                                    },
                                    to: {
                                        autoCSS: !1,
                                        css: {}
                                    },
                                    clipTo: {
                                        autoCSS: !1,
                                        immediateRender: !1,
                                        css: {}
                                    },
                                    layerShouldBeConverted: {
                                        transformOrigin: "50% 50% 0",
                                        x: 0,
                                        y: 0
                                    },
                                    clipShouldBeConverted: {},
                                    ease: "linear",
                                    startAt: "allinend",
                                    repeatDelay: 0,
                                    duration: 1,
                                    count: 0,
                                    yoyo: !1
                                }, hover: {
                                    enabled: null,
                                    from: {
                                        autoCSS: !1,
                                        immediateRender: !1,
                                        css: {}
                                    },
                                    to: {
                                        autoCSS: !1,
                                        css: {}
                                    },
                                    shouldBeConverted: {
                                        transformOrigin: "50% 50% 0"
                                    },
                                    alwaysOnTop: !0,
                                    easeIn: "easeInOutQuint",
                                    durationIn: .5
                                }, parallax: {
                                    enabled: null
                                }, kenBurns: {
                                    scale: 1.2
                                }, clip: {
                                    enabled: !1,
                                    min: "0 0 0 0",
                                    max: "-9999 9999 9999 -9999"
                                }, filter: {
                                    values: {
                                        style: {},
                                        in : {},
                                        out: {},
                                        loop: {},
                                        hover: {},
                                        afterIn: {},
                                        afterLoop: {},
                                        bgFrom: {},
                                        bgTo: {}
                                    },
                                    transitions: {
                                        bg: null,
                                        in : null,
                                        out: null,
                                        loop: null,
                                        hover: null
                                    }
                                }, init: {
                                    wrapper: {
                                        autoCSS: !1,
                                        immediateRender: !1,
                                        css: {
                                            display: "block"
                                        }
                                    }
                                }, transformPerspective: {
                                    layer: 500,
                                    text: 500,
                                    loop: 500,
                                    hover: 500
                                }, reset: {
                                    wrapperOnTimelineEnd: {
                                        autoCSS: !1,
                                        css: {
                                            opacity: 1,
                                            display: "none"
                                        }
                                    },
                                    wrapperOnSlideChange: {
                                        autoCSS: !1,
                                        css: {
                                            x: 0,
                                            y: 0,
                                            rotation: 0,
                                            rotationX: 0,
                                            rotationY: 0,
                                            scaleX: 1,
                                            scaleY: 1,
                                            skewX: 0,
                                            skewY: 0,
                                            opacity: 1,
                                            display: "none"
                                        }
                                    },
                                    loopWrapperOnSlideChange: {
                                        autoCSS: !1,
                                        css: {
                                            x: 0,
                                            y: 0,
                                            rotation: 0,
                                            rotationX: 0,
                                            rotationY: 0,
                                            scaleX: 1,
                                            scaleY: 1,
                                            skewX: 0,
                                            skewY: 0,
                                            opacity: 1
                                        }
                                    }
                                }
                            }
                        };
                        return {
                            is: c.is,
                            should: c.should,
                            elements: c.elements,
                            settings: c.settings,
                            styleSettings: c.styleSettings,
                            mediaSettings: c.mediaSettings,
                            mediaProperties: c.mediaProperties,
                            timeline: c.timeline,
                            in : c.transitionProperties.in,
                            inLayerFrom: c.transitionProperties.in.layerFrom,
                            inLayerFromCSS: c.transitionProperties.in.layerFrom.css,
                            inLayerStyleFrom: c.transitionProperties.in.layerStyleFrom,
                            inLayerStyleFromCSS: c.transitionProperties.in.layerStyleFrom.css,
                            inClipFrom: c.transitionProperties.in.clipFrom,
                            inClipFromCSS: c.transitionProperties.in.clipFrom.css,
                            inLayerTo: c.transitionProperties.in.layerTo,
                            inLayerToCSS: c.transitionProperties.in.layerTo.css,
                            inLayerStyleTo: c.transitionProperties.in.layerStyleTo,
                            inLayerStyleToCSS: c.transitionProperties.in.layerStyleTo.css,
                            inClipTo: c.transitionProperties.in.clipTo,
                            inClipToCSS: c.transitionProperties.in.clipTo.css,
                            inClipShouldBeConverted: c.transitionProperties.in.clipShouldBeConverted,
                            inLayerShouldBeConverted: c.transitionProperties.in.layerShouldBeConverted,
                            inLayerStyleShouldBeConvertedFrom: c.transitionProperties.in.layerStyleShouldBeConvertedFrom,
                            inLayerStyleShouldBeConvertedTo: c.transitionProperties.in.layerStyleShouldBeConvertedTo,
                            textIn: c.transitionProperties.textIn,
                            textInNodesFrom: c.transitionProperties.textIn.nodesFrom,
                            textInNodesTo: c.transitionProperties.textIn.nodesTo,
                            textInNodesToCSS: c.transitionProperties.textIn.nodesTo.css,
                            textInShouldBeConverted: c.transitionProperties.textIn.shouldBeConverted,
                            out: c.transitionProperties.out,
                            outLayerFrom: c.transitionProperties.out.layerFrom,
                            outLayerFromCSS: c.transitionProperties.out.layerFrom.css,
                            outLayerStyleFrom: c.transitionProperties.out.layerStyleFrom,
                            outLayerStyleFromCSS: c.transitionProperties.out.layerStyleFrom.css,
                            outLayerTo: c.transitionProperties.out.layerTo,
                            outLayerToCSS: c.transitionProperties.out.layerTo.css,
                            outLayerStyleTo: c.transitionProperties.out.layerStyleTo,
                            outLayerStyleToCSS: c.transitionProperties.out.layerStyleTo.css,
                            outClipTo: c.transitionProperties.out.clipTo,
                            outClipToCSS: c.transitionProperties.out.clipTo.css,
                            outClipShouldBeConverted: c.transitionProperties.out.clipShouldBeConverted,
                            outLayerShouldBeConverted: c.transitionProperties.out.layerShouldBeConverted,
                            outLayerStyleShouldBeConvertedFrom: c.transitionProperties.out.layerStyleShouldBeConvertedFrom,
                            outLayerStyleShouldBeConvertedTo: c.transitionProperties.out.layerStyleShouldBeConvertedTo,
                            textOut: c.transitionProperties.textOut,
                            textOutNodesFrom: c.transitionProperties.textOut.nodesFrom,
                            textOutNodesTo: c.transitionProperties.textOut.nodesTo,
                            textOutShouldBeConverted: c.transitionProperties.textOut.shouldBeConverted,
                            loop: c.transitionProperties.loop,
                            loopFrom: c.transitionProperties.loop.from,
                            loopFromCSS: c.transitionProperties.loop.from.css,
                            loopTo: c.transitionProperties.loop.to,
                            loopToCSS: c.transitionProperties.loop.to.css,
                            loopClipTo: c.transitionProperties.loop.clipTo,
                            loopClipToCSS: c.transitionProperties.loop.clipTo.css,
                            loopClipShouldBeConverted: c.transitionProperties.loop.clipShouldBeConverted,
                            loopLayerShouldBeConverted: c.transitionProperties.loop.layerShouldBeConverted,
                            hover: c.transitionProperties.hover,
                            hoverFrom: c.transitionProperties.hover.from,
                            hoverFromCSS: c.transitionProperties.hover.from.css,
                            hoverTo: c.transitionProperties.hover.to,
                            hoverToCSS: c.transitionProperties.hover.to.css,
                            hoverShouldBeConverted: c.transitionProperties.hover.shouldBeConverted,
                            parallax: c.transitionProperties.parallax,
                            kenBurns: c.transitionProperties.kenBurns,
                            clip: c.transitionProperties.clip,
                            filter: c.transitionProperties.filter,
                            transformPerspective: c.transitionProperties.transformPerspective,
                            init: c.transitionProperties.init,
                            reset: c.transitionProperties.reset
                        }
                    }
                }
            }, f.slides = {
                count: 0,
                prev: {},
                current: {},
                next: {},
                init: function() {
                    if (!document.body.contains(b)) return !1;
                    for (var d = c.find("> .ls-layer, > .ls-slide"), e = 0, g = f.defaults.slide.keys, h = 0, i = d.length; h < i; h++) {
                        var j = a(d[h]),
                            k = j[0].style,
                            l = {
                                $link: !1,
                                index: -1,
                                data: {
                                    timeShift: 0,
                                    calculatedTimeShift: 0
                                },
                                parallax: {},
                                kenBurns: {
                                    scale: 1.2
                                },
                                filter: {}
                            };
                        if (f.slides.count++, j.removeClass("ls-layer").addClass("ls-slide").css({
                                width: f.slider.initial.originalWidth,
                                height: f.slider.initial.originalHeight
                            }).appendTo(f.slider.$hiddenWrapper), j.data("ls"))
                            for (var m = j.data("ls").toLowerCase().split(";"), n = 0; n < m.length; n++) {
                                var p, q, o = m[n].split(":");
                                o[0] = a.trim(o[0]), o[1] = a.trim(o[1]), "" !== o[0] && "undefined" != typeof g[o[0]] && (p = "undefined" == typeof g[o[0]][1] ? o[0] : g[o[0]][1], q = f.functions.convert.properties(o[1]), p.toLowerCase().indexOf("duration") === -1 && p.toLowerCase().indexOf("delay") === -1 && "timeShift" != p || (q /= 1e3), l[g[o[0]][0]][p] = q)
                            }
                        j.children("a.ls-link").length && (l.data.$link = j.children("a.ls-link").first().css({
                            zIndex: 0
                        }).attr("data-slide-link", e + 1).appendTo(f.slider.$layersWrapper), f.layers.set.smartLinks(l.data.$link)), l.data.$backgroundVideo = j.children('[data-ls*="backgroundvideo"]').first(), l.data.$backgroundVideo.length && (null !== l.data.$backgroundVideo.attr("data-ls").split("backgroundvideo")[1].split(";")[0].match(/(true|enabled|on|1)/i) ? (l.data.$backgroundVideo.addClass("ls-bg-video").css({
                            width: "auto",
                            height: "auto"
                        }).children("video, audio, iframe").css({
                            width: "100%",
                            height: "100%"
                        }), l.data.$backgroundVideo.append(a('<div class="ls-bg-video-overlay"></div>'))) : l.data.$backgroundVideo = !1), j.find("> .ls-bg").length && (l.data.$background = j.find("> .ls-bg").first()), l.data.thumbnail || (j.find("> .ls-tn").length ? l.data.thumbnail = f.functions.getURL(j.find("> .ls-tn").first()) : j.find("> .ls-bg").length ? l.data.thumbnail = f.functions.getURL(j.find("> .ls-bg").first()) : l.data.thumbnail = f.o.skinsPath + f.o.skin + "/nothumb.png"), (l.data.customtransition2d || l.data.customtransition3d) && "undefined" == typeof layerSliderCustomTransitions && (delete l.data.customtransition2d, delete l.data.customtransition3d, f.debugMode && f.debug.add("warn", "sliderInit.customTransitions", e + 1)), "visible" === k.overflow && (l.data.overflow = "visible"), l.data.backgroundColor || (l.data.backgroundColor = "" === j[0].style.backgroundColor ? "transparent" : j[0].style.backgroundColor), f.slides[++e] = {}, f.slides[e].data = a.extend(!0, {}, f.defaults.slide.options.data, l.data), f.slides[e].parallax = l.parallax, f.slides[e].kenBurns = l.kenBurns, f.slides[e].filter = l.filter, f.slides[e].index = e, f.slides[e].$layers = a(), f.slider.thumbnails.push(l.data.thumbnail), f.layers.init(j, e)
                    }
                    f.debugMode && f.debug.groupEnd("sliderInit.style")
                },
                set: {
                    slideIndexes: function() {
                        var a = f.slides;
                        a.prev.index = a.current.index, a.current.index = a.next.index, a.next.index = f.slideshow.get.slideInSequence(f.slideshow.direction), a.set.slidesData()
                    },
                    nextSlideIndex: function(a) {
                        var b = f.slides;
                        b.next.index = a, b.set.slidesData()
                    },
                    slidesData: function() {
                        var b = f.slides;
                        b.prev = b.prev.index !== -1 ? a.extend(!0, {}, b[b.prev.index]) : {}, b.current = b.current.index !== -1 ? a.extend(!0, {}, b[b.current.index]) : {}, b.next = b.next.index !== -1 ? a.extend(!0, {}, b[b.next.index]) : {}
                    },
                    firstSlide: function() {
                        var a = f.slides;
                        if (a.first = {
                                index: f.functions.convert.properties(f.o.firstSlide)
                            }, f.o.shuffleSlideshow && f.slides.count > 2 ? f.o.twoWaySlideshow = !1 : f.o.shuffleSlideshow = !1, a.first.index = "random" == a.first.index ? Math.floor(Math.random() * f.slides.count + 1) : a.first.index, document.location.hash)
                            for (var b = 1; b < a.count + 1; b++) a[b].data.deeplink == document.location.hash.split("#")[1] && (a.first.index = b);
                        a.first.index = a.first.index < 1 || a.first.index > f.slides.count ? 1 : a.first.index, f.o.shuffleSlideshow && "random" != f.o.firstSlide && (a.first.index = f.o.firstSlide), f.o.playByScroll && f.slideshow.set.normalizedSequence(), f.debugMode && f.debug.options.firstSlide && (a.first.index = f.debug.options.firstSlide)
                    }
                },
                slide: []
            }, f.layers = {
                $all: a(),
                getStyle: function(a, b) {
                    return a.indexOf("%") != -1 ? parseFloat(a) * b : parseFloat(a)
                },
                init: function(c, d) {
                    if (!document.body.contains(b)) return !1;
                    for (var g, e = c.find('.ls-bg, .ls-l, .ls-layer, *[class^="ls-s"]'), i = 0, j = e.length; i < j; i++) {
                        var k = a(e[i]),
                            l = k[0],
                            m = k.children();
                        if (k.attr("class").indexOf("ls-s") != -1) {
                            var n = k.attr("class").split("ls-s")[1].split(" ")[0];
                            k.removeClass("ls-s" + n).addClass("ls-layer")
                        } else if (k.hasClass("ls-l")) k.removeClass("ls-l").addClass("ls-layer");
                        else if (!k.is(".ls-bg, .ls-layer")) {
                            k.remove();
                            continue
                        }
                        k.is("a") && 1 === m.length && (k = k.children().first(), l = k[0], l.setAttribute("data-ls", l.parentNode.getAttribute("data-ls")), l.parentNode.removeAttribute("data-ls"), k.parent().removeClass("ls-layer"), k.addClass("ls-layer")), k.data(f.defaults.init.dataKey, new f.defaults.layer.options(k, d)), k.attr("class").indexOf("ls-linkto-") !== -1 && this.set.linkTo(k), k.parent().is("a") ? (g = k.parent(), this.set.smartLinks(g)) : g = k, f.slides[d].$layers = f.slides[d].$layers.add(g)
                    }
                },
                set: {
                    smartLinks: function(b) {
                        var c = b.attr("href"),
                            d = b.attr("target");
                        if (d && d.indexOf("ls-scroll") !== -1 && b.on("click." + e, function(b) {
                                b.preventDefault();
                                var d, e = document.body.scrollHeight - f.device.viewportHeight;
                                if (c && "" !== c) switch (c) {
                                    case "pagetop":
                                        d = 0;
                                        break;
                                    case "pagebottom":
                                        d = f.device.docHeight - f.device.viewportHeight;
                                        break;
                                    case "slidertop":
                                        d = f.slider.offsetTop;
                                        break;
                                    case "sliderbottom":
                                        d = f.slider.offsetTop + f.slider.height;
                                        break;
                                    default:
                                        d = a(c).first().length ? a(c).first().offset().top : f.slider.offsetTop + f.slider.height
                                } else "" === c && (d = f.slider.offsetTop + f.slider.height);
                                d = Math.min(d, e), d = Math.max(0, d), g.TweenMax.to("html, body", 1, {
                                    scrollTop: d,
                                    ease: g.Quint.easeInOut
                                })
                            }), f.defaults.init.controls.indexOf(c) !== -1 || c.match(/^\#[0-9]/)) {
                            var h = a.trim(c.toLowerCase().split("#")[1]),
                                i = parseInt(h);
                            b.on("click." + e, function(a) {
                                if (a.preventDefault(), ["prev", "next", "start", "stop"].indexOf(h) !== -1) f.navigation[h]("clicked");
                                else if ("number" == typeof i && i === i) f.slideshow.changeTo(i, !0, !0);
                                else if (!f.slider.state.changingSlides) switch (h) {
                                    case "replay":
                                        f.api.methods("replay");
                                        break;
                                    case "reverse":
                                        f.api.methods("reverse");
                                        break;
                                    case "reverse-replay":
                                        f.api.methods("reverse", !0)
                                }
                            })
                        }
                    },
                    linkTo: function(b) {
                        for (var d = b.attr("class").split(" "), g = 1, h = 0; h < d.length; h++) d[h].indexOf("ls-linkto-") != -1 && (g = parseInt(d[h].split("ls-linkto-")[1]));
                        b.data(f.defaults.init.dataKey).settings.linkedToSlide = g, b.css({
                            cursor: "pointer"
                        }).on("click." + e, function(b) {
                            b.preventDefault(), c.layerSlider(a(this).data(f.defaults.init.dataKey).settings.linkedToSlide)
                        })
                    },
                    wrappers: function(a, b, c) {
                        b.is.slideBackground || b.is.backgroundVideo ? (b.elements.$bgWrapper = a.closest(".ls-bg-wrap"), b.elements.$bgOuterWrapper = a.closest(".ls-bg-outer")) : (b.elements.$wrapper = a.closest(".ls-in-out"), b.elements.$wrapper.data(f.defaults.init.dataKey, {}), b.settings.wrapperData = b.elements.$wrapper.data(f.defaults.init.dataKey), b.elements.$clipWrapper = a.closest(".ls-clip"), b.elements.$clipWrapper.data(f.defaults.init.dataKey, {}), b.settings.clipWrapperData = b.elements.$clipWrapper.data(f.defaults.init.dataKey), b.elements.$loopWrapper = a.closest(".ls-loop"), b.elements.$loopWrapper.data(f.defaults.init.dataKey, {}), b.settings.loopWrapperData = b.elements.$loopWrapper.data(f.defaults.init.dataKey)), b.parallax.enabled && (b.elements.$parallaxWrapper = a.closest(".ls-parallax"), b.elements.$parallaxWrapper.data(f.defaults.init.dataKey, {
                            parallax: {}
                        }), b.settings.parallaxWrapperData = b.elements.$parallaxWrapper.data(f.defaults.init.dataKey), f.transitions.layers.parallax.addLayer(b.elements.$parallaxWrapper, b.settings.parallaxWrapperData.parallax, b, c)), b.hover.enabled && f.transitions.layers.hover.set(a, b), f.browser.isSafari ? b.elements.$outerWrapper = a.closest(".ls-z") : b.elements.$outerWrapper = b.parallax.enabled ? b.elements.$parallaxWrapper : b.elements.$bgWrapper ? b.elements.$bgOuterWrapper : b.elements.$wrapper
                    },
                    style: function(a) {
                        var h, i, j, k, l, m, p, q, r, s, t, u, v, w, x, y, z, A, B, E, F, H, I, b = a[0],
                            c = a.data(f.defaults.init.dataKey),
                            d = b.style,
                            e = f.layers,
                            n = 0,
                            o = 0,
                            D = !1,
                            G = b.getBoundingClientRect();
                        if (r = "" !== d.paddingLeft ? e.getStyle(d.paddingLeft, f.slider.initial.percW) : parseFloat(a.css("padding-left")), t = "" !== d.paddingRight ? e.getStyle(d.paddingRight, f.slider.initial.percW) : parseFloat(a.css("padding-right")), s = "" !== d.paddingTop ? e.getStyle(d.paddingTop, f.slider.initial.percH) : parseFloat(a.css("padding-top")), u = "" !== d.paddingBottom ? e.getStyle(d.paddingBottom, f.slider.initial.percH) : parseFloat(a.css("padding-bottom")), v = "" !== d.marginLeft ? e.getStyle(d.marginLeft, f.slider.initial.percW) : parseFloat(a.css("margin-left")), w = "" !== d.marginTop ? e.getStyle(d.marginTop, f.slider.initial.percH) : parseFloat(a.css("margin-top")), b.style.margin = "0", y = "" !== d.borderLeftWidth ? parseFloat(d.borderLeftWidth) : parseFloat(a.css("border-left-width")), A = "" !== d.borderRightWidth ? parseFloat(d.borderRightWidth) : parseFloat(a.css("border-right-width")), z = "" !== d.borderTopWidth ? parseFloat(d.borderTopWidth) : parseFloat(a.css("border-top-width")), B = "" !== d.borderBottomWidth ? parseFloat(d.borderBottomWidth) : parseFloat(a.css("border-bottom-width")), 1 === f.media.$allMediaLayers.filter(a).length || a.children("iframe").length) {
                            var J = a.children(),
                                K = J.attr("width") ? J.attr("width") : J.width(),
                                L = J.attr("height") ? J.attr("height") : J.height();
                            300 === parseInt(K) && 150 === parseInt(L) && (K = 640, L = 360), "" !== b.style.width && "auto" !== b.style.width || a.css("width", K), "" !== b.style.height && "auto" !== b.style.height || a.css("height", L), "100%" === d.width && "100%" === d.height && (d.left = "50%", d.top = "50%", c.mediaSettings.fullsize = !0), D = K / L, J.css({
                                width: "100%",
                                height: "100%"
                            })
                        }
                        var M = c.attributes;
                        a.is("img") && (l = a.data("preloadedWidth"), m = a.data("preloadedHeight"), E = l / m, (!d.width && !d.height || "auto" === d.width && "auto" === d.height) && M && (M.width && M.height ? (M.width.indexOf("%") === -1 ? j = parseInt(M.width) : (n = parseInt(M.width), j = e.getStyle(M.width, f.slider.initial.percW)), M.height.indexOf("%") === -1 ? k = parseInt(M.height) : (o = parseInt(M.height), k = e.getStyle(M.height, f.slider.initial.percH))) : M.maxWidth && (a[0].style.width = M.maxWidth + "px", j = M.maxWidth, k = a.height()))), H = G.width ? G.width : G.right - G.left, I = G.height ? G.height : G.bottom - G.top, j || (j = d.width, d.width.indexOf("%") !== -1 && (n = parseInt(d.width)), j = "" !== j && "auto" !== j ? e.getStyle(j, f.slider.initial.percW) : H - r - t - y - A, j = j ? j : "auto"), k || (k = d.height, d.height.indexOf("%") !== -1 && (o = parseInt(d.height)), k = "" !== k && "auto" !== k ? e.getStyle(k, f.slider.initial.percH) : I - s - u - z - B, k = k ? k : "auto"), F = D ? D : j / k, !a.is("img") || d.width || d.height || M && (!M || M.width || M.height) || l === j && m === k || (l !== j ? (j = l > 5 ? l : j, F = l > 5 ? E : F, k = j / F) : m !== k && (k = m > 5 ? m : k, F = m > 5 ? m : F, j = k * F)), h = parseFloat(a.css("opacity")), p = y + r + j + t + A, q = z + s + k + u + B, i = "" !== d.clip && d.clip, d.clip = "", x = d.webkitFilter || d.filter;
                        var N = function(a) {
                            var b = a;
                            return a && a.indexOf("px ") !== -1 && (a = a.replace("px", "").split(" "), b = Math.round(parseInt(a[0]) / j * 100) + "%"), b
                        };
                        c.original = {
                            clip: i,
                            clipShouldBeConverted: !1,
                            left: d.left ? d.left : "0",
                            top: d.top ? d.top : "0",
                            width: Math.ceil(j),
                            height: Math.ceil(k),
                            percentWidth: n,
                            percentHeight: o,
                            outerWidth: p,
                            outerHeight: q,
                            ratio: F,
                            paddingLeft: r,
                            paddingTop: s,
                            paddingRight: t,
                            paddingBottom: u,
                            marginLeft: v,
                            marginTop: w,
                            borderLeftWidth: y,
                            borderTopWidth: z,
                            borderRightWidth: A,
                            borderBottomWidth: B,
                            borderRadius: N(a.css("borderTopLeftRadius")) + " " + N(a.css("borderTopRightRadius")) + " " + N(a.css("borderBottomRightRadius")) + " " + N(a.css("borderBottomLeftRadius")),
                            fontSize: parseFloat(a.css("font-size")),
                            lineHeight: a.css("line-height"),
                            letterSpacing: a.css("letter-spacing"),
                            color: a.css("color"),
                            zIndex: parseInt(a.css("z-index")) || "auto",
                            filter: x,
                            backgroundColor: a.css("background-color"),
                            dataLS: a.attr("data-ls") || "",
                            styles: a.attr("style") || ""
                        }, d.zIndex = "auto", c.responsive = {
                            left: d.left ? d.left : "0",
                            top: d.top ? d.top : "0",
                            width: j,
                            height: k
                        }
                    },
                    properties: function(b, c, d) {
                        var e = b.data(f.defaults.init.dataKey);
                        b.data("ls");
                        if (e.is.textLayer = !b.is("img") && !e.is.mediaLayer, e.self = b, b.data("ls"))
                            for (var i = f.defaults.layer.keys, j = b.data("ls").split(";"), k = b.data("ls").toLowerCase().split(";"), l = 0; l < k.length; l++)
                                if (a.trim(k[l])) {
                                    var m = k[l].indexOf(":"),
                                        n = [k[l].substring(0, m), k[l].substring(m + 1)],
                                        o = null,
                                        p = null,
                                        q = null,
                                        r = null,
                                        s = null;
                                    if (o = a.trim(n[0]), "" !== o)
                                        if (o.replace("split", "text"), "undefined" != typeof i[o]) {
                                            if (p = i[o][0], s = "overlay" === o ? a.trim(j[l].substring(m + 1)) : f.functions.convert.properties(a.trim(n[1])), n[1] && n[1].indexOf("random") !== -1 && (o.match(/(text)/) || (s = f.functions.convert.randomProperties(s, p)), e.should.update || (e.should.update = !0)), "number" == typeof s && p.match(/(duration|startat|shift|delay)/i) && (s /= 1e3), o.match(/(fade)(.+)/)) switch (s) {
                                                case !0:
                                                    s = 0;
                                                    break;
                                                case !1:
                                                    s = 1
                                            }
                                            r = i[o][1], "undefined" != typeof r ? "" !== s ? "object" == typeof s ? o.match(/(text)/) ? r.match(/(converted)/i) ? e[r][p] = s : e[r].cycle[p] = s : (q = f.functions.convert.properties(a.trim(s[0])), f.debugMode && f.debug.add("warn", "layerInit.prop1", [o, s, q]), "number" == typeof q && p.match(/(duration|startat|shift|delay)/i) && (q /= 1e3), e[r][p] = q) : o.match(/(text)/) && s.toString().indexOf("random") !== -1 ? e[r].random[p] = s : e[r][p] = s : f.debugMode && f.debug.add("warn", "layerInit.prop2", o) : e[p][o] = s
                                        } else "clip" === o ? (e.original.clip = n[1], e.original.clipShouldBeConverted = !0) : f.debugMode && f.debug.add("warn", "layerInit.prop4", o)
                                }
                        if (f.browser.isOld && (e.in.enabled = !0, e.textIn.enabled = !1, e.textOut.enabled = !1, e.textIn.type = null, e.textOut.type = null), e.in.enabled && (e.inLayerTo.ease = e.inLayerStyleTo.ease = e.inClipTo.ease = f.functions.convert.easing(e.in.ease)), "undefined" != typeof e.inLayerStyleShouldBeConvertedFrom.borderRadius && (e.inLayerStyleShouldBeConvertedTo.borderRadius = e.original.borderRadius), "undefined" != typeof e.outLayerStyleShouldBeConvertedTo.borderRadius && (e.outLayerStyleShouldBeConvertedFrom.borderRadius = e.original.borderRadius), e.inLayerStyleFromCSS.backgroundColor && (e.inLayerStyleToCSS.backgroundColor = e.original.backgroundColor), e.outLayerStyleToCSS.backgroundColor && (e.outLayerStyleFromCSS.backgroundColor = e.original.backgroundColor), e.inLayerStyleFromCSS.color && (e.inLayerStyleToCSS.color = e.original.color), e.outLayerStyleToCSS.color && (e.outLayerStyleFromCSS.color = e.original.color), "undefined" != typeof e.inLayerStyleShouldBeConvertedFrom.width && (e.inLayerStyleShouldBeConvertedTo.width = e.original.width), "undefined" != typeof e.outLayerStyleShouldBeConvertedTo.width && (e.outLayerStyleShouldBeConvertedFrom.width = e.original.width), "undefined" != typeof e.inLayerStyleShouldBeConvertedFrom.height && (e.inLayerStyleShouldBeConvertedTo.height = e.original.height), "undefined" != typeof e.outLayerStyleShouldBeConvertedTo.height && (e.outLayerStyleShouldBeConvertedFrom.height = e.original.height), "undefined" != typeof e.out.showUntil && 0 !== e.out.showUntil && (e.out.startAt = "transitioninend + " + e.out.showUntil), e.out.startAt.indexOf("slidechangeonly") !== -1 && "slidechangeonly" !== e.out.startAt && (e.out.startAt = "slidechangeonly"), e.out.enabled && (e.outLayerTo.ease = e.outLayerStyleTo.ease = e.outClipTo.ease = f.functions.convert.easing(e.out.ease)), a.isNumeric(e.loop.count) && (e.loop.count > 0 || e.loop.count === -1) && e.loop.enabled !== !1 ? (e.loop.enabled = !0, e.loopTo.ease = e.loopClipTo.ease = f.functions.convert.easing(e.loop.ease), e.loop.count !== -1 ? e.loop.yoyo ? e.loop.repeat = 2 * e.loop.count - 1 : e.loop.repeat = e.loop.count - 1 : e.loop.repeat = -1) : e.loop.enabled = !1, a.isEmptyObject(e.hoverToCSS) || e.hover.enabled === !1 ? e.hover.enabled = !1 : (e.hover.enabled = !0, e.hover.easeOut || (e.hover.easeOut = e.hover.easeIn), e.hover.easeIn = f.functions.convert.easing(e.hover.easeIn), e.hover.easeOut = f.functions.convert.easing(e.hover.easeOut, !0), e.hover.durationOut || (e.hover.durationOut = e.hover.durationIn), g.TweenMax.set(b[0], {
                                autoCSS: !1,
                                css: {
                                    transformPerspective: e.hoverShouldBeConverted.transformPerspective
                                }
                            })), e.parallax.level && a.isNumeric(e.parallax.level) && 0 !== e.parallax.level && e.parallax.enabled !== !1 ? e.parallax.enabled = !0 : e.parallax.enabled = !1, e.is.slideBackground) {
                            var u = {
                                scale: 1,
                                rotation: 0
                            };
                            if (f.slides[c].kenBurns.zoom && (e.kenBurns = f.slides[c].kenBurns), e.kenBurns.zoom) {
                                switch (e.kenBurns.from = {}, e.kenBurns.to = {}, e.kenBurns.zoom) {
                                    case "out":
                                        e.kenBurns.from.scale = e.kenBurns.scale || 1, e.kenBurns.from.rotation = e.kenBurns.rotation || 0, e.kenBurns.to = u;
                                        break;
                                    case "in":
                                        e.kenBurns.from = u, e.kenBurns.to.scale = e.kenBurns.scale || 1, e.kenBurns.to.rotation = e.kenBurns.rotation || 0
                                }
                                delete e.kenBurns.scale, delete e.kenBurns.rotation
                            } else e.kenBurns.from = u, e.kenBurns.to = u;
                            a.isEmptyObject(f.slides[c].filter) || (f.slides[c].filter.from && (e.filter.values.bgFrom = f.transitions.layers.filters.convert(f.slides[c].filter.from)), f.slides[c].filter.to && (e.filter.values.bgTo = f.transitions.layers.filters.convert(f.slides[c].filter.to)))
                        }
                        if (e.textIn.type && f.defaults.layer.splitTypeKeys.indexOf(e.textIn.type) === -1 && (f.debugMode && f.debug.add("warn", "layerInit.splitType3a", [b[0].tagName, e.textIn.type]), delete e.textIn.type, delete e.textIn.ns, e.textIn.enabled = !1), e.textOut.type && f.defaults.layer.splitTypeKeys.indexOf(e.textOut.type) === -1 && (f.debugMode && f.debug.add("warn", "layerInit.splitType3b", [b[0].tagName, e.textOut.type]), delete e.textOut.type, delete e.textOut.ns, e.textOut.enabled = !1), e.textIn.type || e.textOut.type) {
                            var v = 0;
                            if (e.is.textLayer ? (e.textIn.type && (e.textIn.enabled = !0, e.textInNodesTo.ease = f.functions.convert.easing(e.textInNodesTo.ease), e.textIn.split = e.textIn.type.split("_")[0], b.children().length && f.debugMode && (v = 1)), e.textOut.type && (e.textOut.enabled = !0, e.textOutNodesTo.ease = f.functions.convert.easing(e.textOutNodesTo.ease)), e.textOut.enabled && e.textOut.type.split("_")[0] !== e.textIn.split && (e.textIn.split += ", " + e.textOut.type.split("_")[0], b.children().length && f.debugMode && (v = 1)), e.textIn.split.indexOf("chars") !== -1 && e.textIn.split.indexOf("words") === -1 && (e.textIn.split += ", words"), e.textIn.split.indexOf("words") !== -1 && e.textIn.split.indexOf("lines") === -1 && (e.textIn.split += ", lines")) : (delete e.textIn.type, delete e.textOut.type, delete e.textIn.ns, delete e.textOut.ns, f.debugMode && (v = 2)), f.debugMode && 0 !== v && c && !d) switch (v) {
                                case 1:
                                    f.debug.add("warn", "layerInit.splitType1", [b.prop("nodeName"), c]);
                                    break;
                                case 2:
                                    f.debug.add("warn", "layerInit.splitType2", [c, b.prop("nodeName")])
                            }
                        }
                        if ((e.original.clip || e.inClipShouldBeConverted.clip || e.outClipShouldBeConverted.clip || e.loopClipShouldBeConverted.clip) && (e.clip.enabled = !0), e.in.enabled && e.inLayerToCSS.scale && (delete e.inLayerToCSS.scaleX, delete e.inLayerToCSS.scaleY), e.out.enabled && e.outLayerToCSS.scale && (delete e.outLayerToCSS.scaleX, delete e.outLayerToCSS.scaleY), e.inLayerStyleShouldBeConvertedFrom.filter && (e.filter.values.in = f.transitions.layers.filters.convert(e.inLayerStyleShouldBeConvertedFrom.filter)), e.filter.values.style = f.transitions.layers.filters.convert(e.original.filter), e.outLayerStyleShouldBeConvertedTo.filter && (e.filter.values.out = f.transitions.layers.filters.convert(e.outLayerStyleShouldBeConvertedTo.filter)), e.loopLayerShouldBeConverted.filter && (e.filter.values.loop = f.transitions.layers.filters.convert(e.loopLayerShouldBeConverted.filter)), e.hoverShouldBeConverted.filter && (e.filter.values.hover = f.transitions.layers.filters.convert(e.hoverShouldBeConverted.filter)), e.in.enabled || (e.in.duration = 0), e.textIn.enabled || (e.textIn.duration = 0), e.loop.enabled || (e.loop.duration = 0), e.textOut.enabled || (e.textOut.duration = 0), e.out.enabled || (e.out.duration = 0), b.attr("data-slidein", c), "undefined" != typeof e.settings.static && "none" !== e.settings.static) {
                            var w = parseInt(e.settings.static);
                            0 !== w && "forever" !== e.settings.static ? (b.attr("data-slideout", w), e.settings.slideOut = w) : e.settings.slideOut = 0, e.is.static = !0, b.attr("data-static", "1")
                        } else b.attr("data-slideout", c);
                        e.mediaSettings.volume && (e.mediaSettings.volume < 0 ? e.mediaSettings.volume = 0 : e.mediaSettings.volume > 100 && (e.mediaSettings.volume = 100)), e.is.backgroundVideo && (f.media.setBackgroundVideo(e, b), e.styleSettings.overlay && b.find(".ls-bg-video-overlay").css({
                            backgroundImage: "url(" + e.styleSettings.overlay + ")"
                        })), e.styleSettings.minfontsize && (e.styleSettings.minfontsize = parseFloat(e.styleSettings.minfontsize)), e.styleSettings.minmobilefontsize && (e.styleSettings.minmobilefontsize = parseFloat(e.styleSettings.minmobilefontsize))
                    }
                },
                get: function(a) {
                    var b = this.$all;
                    if (a) {
                        a = a.toLowerCase();
                        var c = "in",
                            d = "",
                            e = "",
                            g = ':not(".ls-bg")',
                            h = ':not(".ls-bg-video")';
                        a.indexOf("bgvideo") == -1 && a.indexOf("backgroundvideo") == -1 || (h = "", a = a.replace("bgvideo", "").replace("backgroundvideo", "")), a.indexOf("video") != -1 && (e += ", > video", a = a.replace("video", "")), a.indexOf("audio") != -1 && (e += ", > audio", a = a.replace("audio", "")), a.indexOf("html5") != -1 && (e += ", > video, > audio", a = a.replace("html5", "")), a.indexOf("youtube") != -1 && (e += ', > iframe[src*="youtube-nocookie.com"], > iframe[src*="youtube.com"], > iframe[src*="youtu.be"], > iframe[data-src*="youtube-nocookie.com"], > iframe[data-src*="youtube.com"], > iframe[data-src*="youtu.be"]', a = a.replace("youtube", "")), a.indexOf("vimeo") != -1 && (e += ', > iframe[src*="player.vimeo"], > iframe[data-src*="player.vimeo"]', a = a.replace("vimeo", "")), "," == e.charAt(0) && (e = e.substring(2, e.length)), a.indexOf("out") != -1 && (c = "out"), a.indexOf("img") == -1 && a.indexOf("image") == -1 || (d = "img"), a.indexOf("bg") == -1 && a.indexOf("background") == -1 && a.indexOf("bgonly") == -1 || (g = ""), b = a.indexOf("current") != -1 ? b.filter(d + "[data-slide" + c + '="' + f.slides.current.index + '"]' + g + h) : a.indexOf("next") != -1 ? b.filter(d + "[data-slide" + c + '="' + f.slides.next.index + '"]' + g + h) : b.filter(d + g + h), a.indexOf("notactive") != -1 && (b = b.filter(".ls-bg, .ls-bg-video, :hidden"), a = a.replace("notactive", "")), a.indexOf("active") != -1 && (b = b.filter(":visible:not(.ls-bg, .ls-bg-video)"), a = a.replace("active", "")), a.indexOf("notstatic") != -1 && (b = b.filter(':not([data-static="1"])'), a = a.replace("notstatic", "")), a.indexOf("static") != -1 && (b = b.filter('[data-static="1"]'), a = a.replace("static", "")), a.indexOf("bgonly") != -1 && (b = b.filter(".ls-bg"), a = a.replace("bgonly", "")), "" !== e && (b = b.find(e))
                    }
                    return b
                },
                update: {
                    data: function(b, c, d) {
                        var e, g, h;
                        switch (b instanceof jQuery || (b = a(b)), d && b.attr("data-ls", d).data("ls", d), g = b.data(f.defaults.init.dataKey), e = g.is.onSlide, h = g.original, c) {
                            default:
                                case "transitions":
                                g.settings.timelineIsCalculated = !1,
                            f.layers.set.properties(b, e, !0);
                            break;
                            case "all":
                                    b.data(f.defaults.init.dataKey, new f.defaults.layer.options(b, e)),
                                g = b.data(f.defaults.init.dataKey),
                                g.original = h,
                                f.layers.set.properties(b, e, !0),
                                f.layers.set.wrappers(b, g, e)
                        }
                    }
                },
                wrap: function(b, d) {
                    if (!f.slides[b].wrapped && "wrapping" !== f.slides[b].wrapped) {
                        f.slides[b].wrapped = "wrapping";
                        var e = d ? 25 : 0,
                            g = f.slides[b].$layers,
                            h = g.length;
                        g.each(function(d, g) {
                            f.timeouts["slide-" + b + "-layer-" + d] = setTimeout(function() {
                                delete f.timeouts["slide-" + b + "-layer-" + d];
                                var k, e = a(g),
                                    i = e,
                                    j = "",
                                    l = !1,
                                    m = "";
                                e.hasClass("ls-hide-phone") && (m += " ls-hide-on-phone"), e.hasClass("ls-hide-tablet") && (m += " ls-hide-on-tablet"), e.hasClass("ls-hide-desktop") && (m += " ls-hide-on-desktop"), e.removeClass("ls-hide-phone ls-hide-tablet ls-hide-desktop"), i.is("a") && 1 === i.children().length && (l = !0, e = i.find(".ls-layer"));
                                var n = e.data(f.defaults.init.dataKey);
                                if (!n) return !0;
                                if (k = f.slider.$layersWrapper, n.is.backgroundVideo ? k = f.slider.$bgVideosWrapper : n.is.slideBackground && (k = f.slider.$slideBGWrapper), f.layers.set.style(e), f.layers.set.properties(e, b), n.textIn.split) {
                                    var o = new SplitType(e[0], {
                                        split: n.textIn.split
                                    });
                                    n.textIn.type && (n.textIn.ns = o[n.textIn.type.split("_")[0]]), n.textOut.type && (n.textOut.ns = o[n.textOut.type.split("_")[0]])
                                }
                                n.is.slideBackground || n.is.backgroundVideo ? j = '<div class="ls-wrapper ls-bg-outer"><div class="ls-wrapper ls-bg-wrap"></div></div>' : (n.clip.enabled && (j = '<div class="ls-wrapper ls-clip"></div>'), n.loop.enabled && (j = '<div class="ls-wrapper ls-loop">' + j + "</div>"), j = '<div class="ls-wrapper ls-in-out">' + j + "</div>"), n.parallax.enabled && (j = '<div class="ls-wrapper ls-parallax">' + j + "</div>"), f.browser.isSafari && (j = '<div class="ls-wrapper ls-z">' + j + "</div>"), "" !== j ? e.appendTo(k).wrap(j) : e.appendTo(k), l === !0 && i.addClass("ls-layer-link").appendTo(e.parent());
                                var p = {},
                                    q = e.css("mix-blend-mode");
                                q && "normal" !== q && (p["mix-blend-mode"] = q, e.css("mix-blend-mode", "normal")), n.original.customZIndex = 1;
                                var r = parseInt(n.original.zIndex);
                                n.is.backgroundVideo ? p = {
                                    zIndex: n.original.customZIndex
                                } : n.is.slideBackground ? p = {
                                    zIndex: n.original.customZIndex
                                } : (r || (r = d + 101), p.zIndex = r, n.original.customZIndex = r), f.browser.isSafari && (p.transform = "translateZ(" + 3e3 * r + "px )"), f.layers.set.wrappers(e, n, b), n.elements.$outerWrapper.css(p).addClass(m), n.is.slideBackground && n.elements.$bgWrapper.css({
                                    backgroundColor: f.slides[b].data.backgroundColor
                                }), f.layers.$all = f.layers.$all.add(e), f.slides[b].$layers = f.slides[b].$layers.not(i), d === h - 1 && (c.children(".ls-slide").eq(b - 1).empty(), f.slides[b].wrapped = !0)
                            }, e * (d + 1))
                        })
                    }
                }
            }, f.slideshow = {
                direction: "next",
                nextLoop: 0,
                firstStart: !0,
                sequence: {
                    normal: [],
                    randomized: []
                },
                state: {
                    running: !0,
                    paused: !1,
                    pausedByVideo: !1,
                    pausedByHover: !1,
                    pausedByLastCycle: !1
                },
                should: {
                    change: !1,
                    start: !1,
                    stop: !1
                },
                isPaused: function() {
                    return this.state.paused || this.state.pausedByVideo || this.state.pausedByHover
                },
                init: function() {
                    1 == f.slides.count && (f.o.autoStart = !1, f.o.navPrevNext = !1, f.o.navStartStop = !1, f.o.navButtons = !1, f.o.cycles = -1, f.o.forceLoopNum = !1, f.o.autoPauseSlideshow = !0, f.o.firstSlide = 1, f.o.thumbnailNavigation = "disabled"), f.o.autoStart && 1 != f.slides.count || f.functions.setStates(this, {
                        running: !1,
                        paused: !0
                    }), this.set.pauseOnHover(), this.set.sequences()
                },
                set: {
                    pauseOnHover: function() {
                        f.o.pauseOnHover = f.o.pauseOnHover === !0 ? f.defaults.init.options.pauseOnHover : f.o.pauseOnHover, f.o.pauseOnHover !== !1 && c.on("mouseenter." + e, function() {
                            f.slider.state.inFullscreen || (f.functions.setStates(f.slideshow, {
                                pausedByHover: !0
                            }), "slideshowOnly" !== f.o.pauseOnHover && f.transitions.layers.timeline.pause())
                        }).on("mouseleave." + e, function() {
                            var b = 1;
                            f.transitions._slideTimeline && f.transitions._slideTimeline.duration() > f.transitions.layers.timeline.totalDuration && (b = f.transitions.layers.timeline.totalDuration / f.transitions._slideTimeline.duration()), f.functions.setStates(f.slideshow, {
                                pausedByHover: !1
                            }), a("body").hasClass("ls-unselectable") || "slideshowOnly" === f.o.pauseOnHover || f.o.pauseLayers && f.slideshow.isPaused() || f.transitions.layers.timeline.resume(), f.transitions._slideTimeline && f.transitions.layers.timeline.state.finished && f.transitions._slideTimeline.progress() < b && f.functions.setStates(f.transitions.layers.timeline, {
                                finished: !1
                            }), f.slideshow.start()
                        })
                    },
                    sequences: function() {
                        for (var b = 0; b < f.slides.count; b++) f.slideshow.sequence.normal[b] = b + 1;
                        f.slideshow.sequence.randomized = f.functions.shuffleArray(a.merge([], f.slideshow.sequence.normal))
                    },
                    normalizedSequence: function() {
                        var a = f.o.shuffleSlideshow ? "randomized" : "normal",
                            b = f.slideshow.sequence[a],
                            c = f.slideshow.sequence[a].length,
                            d = b.indexOf(f.slides.first.index);
                        f.slideshow.sequence.normalized = [];
                        for (var e = d; e < c; e++) f.slideshow.sequence.normalized.push(b[e]);
                        for (var g = 0; g < d; g++) f.slideshow.sequence.normalized.push(b[g])
                    },
                    prevNext: function(a) {
                        switch (a) {
                            case "prev":
                                f.o.twoWaySlideshow && (f.slideshow.direction = "prev"), f.slideshow.changeTo(f.slideshow.get.slideInSequence("prev"), !0);
                                break;
                            case "next":
                                f.slideshow.direction = "next", f.slideshow.changeTo(f.slideshow.get.slideInSequence("next"), !0)
                        }
                    }
                },
                get: {
                    sequence: function() {
                        var a = "normal";
                        return f.o.playByScroll ? a = "normalized" : f.o.shuffleSlideshow && (a = "randomized"), a
                    },
                    slideInSequence: function(a) {
                        var b = f.slideshow.sequence[this.sequence()],
                            c = b.indexOf(f.slides.current.index);
                        switch (a) {
                            case "prev":
                                return 0 === c ? b[b.length - 1] : b[c - 1];
                            case "next":
                                return c === b.length - 1 ? b[0] : b[c + 1];
                            default:
                                return b[a]
                        }
                    },
                    indexOfSlideInSequence: function(a) {
                        return f.slideshow.sequence[this.sequence()].indexOf(a)
                    }
                },
                cycles: {set: function() {
                        f.o.cycles > 0 && (f.slideshow.curCycle = 1, f.slideshow.cycleSlideIndex = f.slideshow.get.indexOfSlideInSequence(f.slides.first.index))
                    },
                    check: function(a) {
                        if (f.slideshow.get.indexOfSlideInSequence(a) === f.slideshow.cycleSlideIndex) return ++f.slideshow.curCycle === f.o.cycles + 1
                    }
                },
                start: function(a) {
                    !this.isPaused() && f.transitions._slideTimeline && f.transitions.layers.timeline.state.finished && this.changeTo(f.slides.next.index)
                },
                stop: function() {
                    f.functions.setStates(this, {
                        running: !1,
                        paused: !0
                    })
                },
                changeTo: function(d, e, g) {
                    if (!document.body.contains(b)) return !1;
                    if (!this.firstStart && f.api.hasEvent("slideChangeWillStart")) {
                        var h = c.triggerHandler("slideChangeWillStart", f.api.eventData());
                        if (h === !1) return;
                        a.isNumeric(h) && (d = parseInt(h))
                    }
                    return d > f.slides.count || d < 1 ? void(f.debugMode && (f.debug.add("group", "slideshow"), f.debug.add("warn", "slideshow.invalidSlideIndex", [d, f.slides.count]), f.debug.groupEnd())) : void(f.slider.isBusy() || f.slideshow.state.pausedByVideo && !e ? !f.slider.state.preloadingImages && f.slider.state.animatingSlides && f.transitions._slideTransition && (f.slideshow.should.change = !0, f.transitions._slideTransition.progress(1), f.transitions._forceLayersOut && f.transitions._forceLayersOut.progress(1)) : (f.functions.setStates(f.transitions.layers.timeline, {
                        finished: !1
                    }), f.slideshow.should.change = !1, f.debugMode && f.debug.add("group", "slideshow"), e ? ("prev" === f.navigation.direction && f.o.twoWaySlideshow && (f.slideshow.direction = "prev"), f.debugMode && (f.debug.add("log", "slideshow.changedByUser", !1), f.o.twoWaySlideshow && f.debug.add("log", "slideshow.setdir", f.slideshow.direction))) : f.navigation.direction = f.slideshow.direction, f.transitions.timers.reverse(), f.media.stop(), f.slides.set.nextSlideIndex(d), f.debugMode && (f.debug.add("log", "slideshow.change", [f.slides.current.index, f.slides.next.index, f.slideshow.direction, f.navigation.direction]), f.debug.groupEnd()), f.functions.setStates(this, {
                        pausedByVideo: !1
                    }), f.functions.setStates(f.slider, {
                        changingSlides: !0
                    }), f.preload.imagesOfSlide(f.slides.next.index, function() {
                        f.transitions.start()
                    })))
                },
                forceStop: function() {
                    f.navigation.stop(), a.each(f.timeouts, function(a, b) {
                        clearTimeout(f.timeouts[a])
                    }), f.transitions.timers.stop(), f.transitions._slideTimeline.stop(), f.functions.setStates(f.transitions.layers.timeline, {
                        stopped: !0,
                        running: !1
                    }), c.find("*").stop(!0, !1).dequeue()
                },
                restart: function() {
                    c.find("*").stop(), f.navigation.change(f.slides.current.index, f.slideshow.direction)
                }
            }, f.media = {
                errors: {},
                $allMediaLayers: a(),
                protocol: "http:",
                playingInCurSlide: 0,
                endedInCurSlide: 0,
                init: function() {
                    document.location.href.indexOf("https:") != -1 && (this.protocol = "https:"), f.functions.setStates(f.slider, {
                        waitingForYouTube: !1,
                        waitingForVimeo: !1
                    }), f.media.youtube.init(), f.media.vimeo.init(), f.media.html5.init()
                },
                youtube: {
                    init: function() {
                        var b = 0;
                        this.$videos = f.slider.$hiddenWrapper.find('iframe[src*="youtube-nocookie.com"], iframe[src*="youtube.com"], iframe[src*="youtu.be"], iframe[data-src*="youtube-nocookie.com"], iframe[data-src*="youtube.com"], iframe[data-src*="youtu.be"]').each(function() {
                            var c = a(this),
                                d = c.parent(),
                                e = d.data(f.defaults.init.dataKey),
                                g = (c.attr("src") || c.attr("data-src")).replace("autoplay=1", "autoplay=0").replace("?", "?smart=true&"),
                                h = g.indexOf("http") === -1 ? f.media.protocol : "",
                                i = g.indexOf("?") === -1 ? "?" : "&",
                                j = "wmode=opaque&html5=1&enablejsapi=1&version=3",
                                k = {
                                    $videoElement: c,
                                    videoURL: h + g + i + j,
                                    videoThumbnailURL: f.media.protocol + "//img.youtube.com/vi/" + g.split("embed/")[1].split("?")[0] + "/" + f.o.youtubePreview
                                };
                            c.attr("id", "ls-youtube-" + ++b), e.mediaProperties = {
                                type: "youtube",
                                saved: k
                            }, f.media.setProperties(e), e.is.backgroundVideo && f.media.setBackgroundVideo(e, d), e.is.backgroundVideo || f.media.setMediaElements(d, c, k.videoURL, k.videoThumbnailURL, e)
                        }), f.media.$allMediaLayers = f.media.$allMediaLayers.add(this.$videos.parent()), this.$videos.length && (f.timeouts.loadYouTube = Math.floor(Date.now() / 1e3), window.YT || a("<script>").attr({
                            src: "https://www.youtube.com/iframe_api",
                            type: "text/javascript"
                        }).appendTo("head"), window.onYouTubeIframeAPIReady = function() {
                            window._layerSlider.globals.youTubeIsReady = !0
                        }, f.intervals.isYouTubeReady = setInterval(function() {
                            window.YT && 1 === window.YT.loaded || window._layerSlider.globals.youTubeIsReady || Math.floor(Date.now() / 1e3) - f.timeouts.loadYouTube > 3 ? (clearInterval(f.intervals.isYouTubeReady), delete f.intervals.isYouTubeReady, delete f.timeouts.loadYouTube, f.media.youtube.$videos.parent().each(function() {
                                var b = a(this),
                                    c = b.data(f.defaults.init.dataKey),
                                    d = c.mediaProperties.saved;
                                b.on("playVideo." + e + " click." + e, ".ls-vpcontainer", function() {
                                    f.media.hideThumbnail(a(this)), f.media.checkSlideshowState(b, c), f.media.removeFromTimeline(b), f.media.youtube.play(b, d.$videoElement, d.videoURL, c)
                                }).on("playBackgroundVideo." + e, function() {
                                    f.media.youtube.play(b, d.$videoElement, d.videoURL, c)
                                }).on("stopBackgroundVideo." + e, function() {
                                    f.media.youtube.stop(b, d.$videoElement, c)
                                }).on("preloadBackgroundVideo." + e, function() {
                                    f.media.youtube.createPlayer(b, d.$videoElement, d.videoURL, c, !0)
                                })
                            }), f.functions.setStates(f.slider, {
                                waitingForYouTube: !1
                            })) : f.functions.setStates(f.slider, {
                                waitingForYouTube: !0
                            })
                        }, 25))
                    },
                    createPlayer: function(a, b, c, d, e) {
                        var g = function() {
                                null !== d.mediaSettings.volume && d.mediaProperties.player.setVolume(d.mediaSettings.volume), e && !d.mediaProperties.shouldPlay || (d.mediaProperties.player.playVideo(), d.mediaProperties.shouldPlay = !1)
                            },
                            h = function(b) {
                                0 === b.data && (d.is.backgroundVideo ? d.mediaProperties.player.seekTo(0) : f.media.videoEnded(a, d))
                            };
                        if (null !== d.mediaSettings.showinfo) switch (d.mediaSettings.showinfo) {
                            default: c.replace("&showinfo=0", "").replace("&showinfo=1", "");
                            case !0:
                                    c += "&showinfo=1";
                                break;
                            case !1:
                                    c += "&showinfo=0"
                        }
                        if (null !== d.mediaSettings.controls) switch (d.mediaSettings.controls) {
                            default: c.replace("&controls=0", "").replace("&controls=1", "");
                            case !0:
                                    c += "&controls=1";
                                break;
                            case !1:
                                    c += "&controls=0"
                        }
                        b.attr("src", c), d.mediaProperties.player = new YT.Player(b[0], {
                            events: {
                                onReady: g,
                                onStateChange: h
                            }
                        })
                    },
                    play: function(a, b, c, d) {
                        d.mediaProperties.player ? d.mediaProperties.player.playVideo ? d.mediaProperties.player.playVideo() : d.mediaProperties.shouldPlay = !0 : this.createPlayer(a, b, c, d)
                    },
                    stop: function(a, b, c) {
                        c.mediaProperties.player && (c.mediaProperties.player.pauseVideo().seekTo(0), c.is.backgroundVideo || f.media.showThumbnail(a.find(".ls-vpcontainer")))
                    }
                },
                vimeo: {
                    init: function() {
                        var b = this.$videos = f.slider.$hiddenWrapper.find('iframe[src*="player.vimeo"], iframe[data-src*="player.vimeo"]');
                        if (b.length) {
                            f.timeouts.loadVimeo = Math.floor(Date.now() / 1e3), f.media.$allMediaLayers = f.media.$allMediaLayers.add(b.parent());
                            var c = 0;
                            a("<script>").attr({
                                src: f.media.protocol + "//f.vimeocdn.com/js/froogaloop2.min.js",
                                type: "text/javascript"
                            }).appendTo("head"), f.intervals.isVimeoReady = setInterval(function() {
                                f.functions.setStates(f.slider, {
                                    waitingForVimeo: !0
                                }), (window.Froogaloop || Math.floor(Date.now() / 1e3) - f.timeouts.loadVimeo > 3) && (clearInterval(f.intervals.isVimeoReady), delete f.intervals.isVimeoReady, delete f.timeouts.loadVimeo, window._layerSlider.globals.vimeoIsReady = !0, d())
                            }, 25);
                            var d = function() {
                                f.media.vimeo.$videos.each(function() {
                                    var b = a(this).attr("id", "ls-vimeo-" + ++c),
                                        d = b.parent(),
                                        g = d.data(f.defaults.init.dataKey),
                                        h = (b.attr("src") || b.attr("data-src")).replace("autoplay=1", "autoplay=0").replace("?", "?smart=true&"),
                                        i = h.indexOf("?") === -1 ? "?" : "&",
                                        j = h.indexOf("http") === -1 ? f.media.protocol : "",
                                        k = "wmode=opaque&api=1&player_id=ls-vimeo-" + c,
                                        l = f.media.protocol + "//vimeo.com/api/v2/video/" + h.split("video/")[1].split("?")[0] + ".json?callback=?",
                                        m = j + h + i + k;
                                    g.mediaProperties = {
                                        type: "vimeo",
                                        saved: {}
                                    }, f.media.setProperties(g), g.is.backgroundVideo && f.media.setBackgroundVideo(g, d), a.getJSON(l, function(a) {
                                        g.is.backgroundVideo || f.media.setMediaElements(d, b, m, a[0].thumbnail_large, g)
                                    }), d.on("playVideo." + e + " click." + e, ".ls-vpcontainer", function() {
                                        f.media.hideThumbnail(a(this)), f.media.checkSlideshowState(d, g), f.media.removeFromTimeline(d), f.media.vimeo.play(d, b, m, g)
                                    }).on("playBackgroundVideo." + e, function() {
                                        f.media.vimeo.play(d, b, m, g)
                                    }).on("stopBackgroundVideo." + e, function() {
                                        f.media.vimeo.stop(d, b, g)
                                    }).on("preloadBackgroundVideo." + e, function() {
                                        f.media.vimeo.createPlayer(d, b, m, g, !0)
                                    })
                                }), f.functions.setStates(f.slider, {
                                    waitingForVimeo: !1
                                })
                            }
                        }
                    },
                    createPlayer: function(a, b, c, d, e) {
                        if (null !== d.mediaSettings.showinfo) switch (d.mediaSettings.showinfo) {
                            default: c.replace("&title=0", "").replace("&title=1", "").replace("&byline=0", "").replace("&byline=1", "").replace("&portrait=0", "").replace("&portrait=1", "");
                            case !0:
                                    c.replace("title=0", "title=1", "").replace("byline=0", "byline=1", "").replace("portrait=0", "portrait=1", "");
                                break;
                            case !1:
                                    c.replace("title=1", "title=0", "").replace("byline=1", "byline=0", "").replace("portrait=1", "portrait=0", "")
                        }
                        b.attr("src", c);
                        var g = function() {
                            d.is.backgroundVideo ? d.mediaProperties.player.api("seekTo", 0).api("play") : f.media.videoEnded(a, d)
                        };
                        d.mediaProperties.player = $f(b[0]), d.mediaProperties.player.addEvent("ready", function() {
                            d.mediaProperties.player.addEvent("finish", g), null !== d.mediaSettings.volume && d.mediaProperties.player.api("setVolume", d.mediaSettings.volume / 100), e || d.mediaProperties.player.api("play")
                        })
                    },
                    play: function(a, b, c, d) {
                        d.mediaProperties.player ? d.mediaProperties.player.api("play") : this.createPlayer(a, b, c, d)
                    },
                    stop: function(a, b, c) {
                        c.mediaProperties.player && (c.mediaProperties.player.api("pause").api("seekTo", 0), c.is.backgroundVideo || f.media.showThumbnail(a.find(".ls-vpcontainer")))
                    }
                },
                html5: {
                    init: function() {
                        if (this.$elements = f.slider.$hiddenWrapper.find("video, audio"), f.media.$allMediaLayers = f.media.$allMediaLayers.add(this.$elements.parent()), this.$elements.length) {
                            var b = 0;
                            f.media.html5.$elements.each(function() {
                                var c = a(this).attr("id", "ls-html5-" + ++b),
                                    d = a(this).parent(),
                                    g = d.data(f.defaults.init.dataKey);
                                if (g.mediaProperties = {
                                        type: "html5",
                                        saved: {}
                                    }, f.media.setProperties(g), g.is.backgroundVideo && f.media.setBackgroundVideo(g, d), c.attr("autoplay")) {
                                    var h = c.removeAttr("autoplay").clone(!0, !0);
                                    c.remove(), c = h.appendTo(d), d.data("ls", d.data("ls") + " autoplay: true;")
                                }
                                g.is.backgroundVideo || f.media.setMediaElements(d, c, !1, !1, g), c.on("ended." + e, function() {
                                    g.is.backgroundVideo ? (c[0].currentTime = 0, c[0].play()) : f.media.videoEnded(d, g)
                                }), d.on("playVideo." + e + " click." + e, ".ls-vpcontainer", function(b) {
                                    f.media.hideThumbnail(a(this)), f.media.checkSlideshowState(d, g), f.media.removeFromTimeline(d), f.media.html5.play(d, c, g)
                                }).on("playBackgroundVideo." + e, function() {
                                    f.media.html5.play(d, c, g)
                                }).on("stopBackgroundVideo." + e, function() {
                                    f.media.html5.stop(d, c, g)
                                })
                            })
                        }
                    },
                    play: function(a, b, c) {
                        if (c.mediaProperties.saved.controls) switch (c.mediaProperties.saved.controls) {
                            case !0:
                                b.prop("controls", !0);
                                break;
                            case !1:
                                b.prop("controls", !1)
                        } else b.prop("controls", c.mediaSettings.controls);
                        null === c.mediaSettings.volume || c.mediaProperties.volumeIsSet || (b[0].volume = c.mediaSettings.volume / 100, c.mediaProperties.volumeIsSet = !0), b[0].play()
                    },
                    stop: function(a, b, c) {
                        b[0].pause(), b[0].currentTime = 0, b.prop("controls", !1), c.is.backgroundVideo || f.media.showThumbnail(a.find(".ls-vpcontainer"))
                    }
                },
                setBackgroundVideo: function(b, c) {
                    if (b.mediaSettings = {
                            controls: !1,
                            autoplay: !1,
                            showinfo: !1,
                            fillmode: "cover",
                            thumbnail: !1,
                            volume: 0
                        }, c.data("ls") && c.data("ls").indexOf("poster:") !== -1 && 0 == c.children(".ls-vpcontainer").length) {
                        var d = a("<div>").addClass("ls-vpcontainer").appendTo(c),
                            e = c.data("ls").split("poster:")[1].split(";")[0].trim();
                        a("<div>").appendTo(d).addClass("ls-videopreview").attr({
                            style: "background-image: url(" + e + ")"
                        })
                    }
                },
                setProperties: function(a) {
                    a.is.mediaLayer = !0
                },
                setMediaElements: function(b, c, d, e, f) {
                    var g = a("<div>").addClass("ls-vpcontainer").appendTo(b);
                    a("<div>").appendTo(g).addClass("ls-playvideo"), b.data("ls") && b.data("ls").indexOf("poster:") !== -1 && (e = b.data("ls").split("poster:")[1].split(";")[0].trim()), c.is("iframe") ? a("<div>").appendTo(g).addClass("ls-videopreview").attr({
                        style: "background-image: url(" + e + ")"
                    }) : (c.is("video") && (f.mediaProperties.saved.controls = c.prop("controls"), c.prop("controls", !1)), e || "undefined" == typeof c.attr("poster") || (e = c.attr("poster"), c.removeAttr("poster")), e && a("<div>").appendTo(g).addClass("ls-videopreview").attr({
                        style: "background-image: url(" + e + ")"
                    }))
                },
                checkSlideshowState: function(a, b) {
                    !b.is.static && f.o.autoPauseSlideshow && (f.functions.setStates(f.slideshow, {
                        pausedByVideo: !0
                    }), "auto" == f.o.autoPauseSlideshow && this.playingInCurSlide++)
                },
                hideThumbnail: function(a) {
                    a.delay(f.transitions.media.defaults.delay).fadeOut(f.transitions.media.defaults.fadeOut)
                },
                showThumbnail: function(a) {
                    a.fadeIn(f.transitions.media.defaults.fadeIn)
                },
                videoEnded: function(a, b) {
                    "auto" != f.o.autoPauseSlideshow || b.is.backgroundVideo || (b.is.static || this.endedInCurSlide++, this.endedInCurSlide == this.playingInCurSlide && 0 !== this.playingInCurSlide && (f.functions.setStates(f.slideshow, {
                        pausedByVideo: !1
                    }), f.slideshow.remainingSlideDuration = 1, f.slideshow.start()))
                },
                stop: function() {
                    var b = this;
                    f.layers.get("current,out,youtube").each(function() {
                        var c = a(this),
                            d = c.closest(".ls-layer"),
                            e = d.data(f.defaults.init.dataKey);
                        b.youtube.stop(d, c, e)
                    }), f.layers.get("current,out,vimeo").each(function() {
                        var c = a(this),
                            d = c.closest(".ls-layer"),
                            e = d.data(f.defaults.init.dataKey);
                        b.vimeo.stop(d, c, e)
                    }), f.layers.get("current,out,html5").each(function() {
                        var c = a(this),
                            d = c.closest(".ls-layer"),
                            e = d.data(f.defaults.init.dataKey);
                        b.html5.stop(d, c, e)
                    }), this.playingInCurSlide = 0, this.endedInCurSlide = 0
                },
                removeFromTimeline: function(a) {
                    f.transitions._slideTimeline.kill(null, a.closest(".ls-in-out")[0])
                }
            }, f.yourLogo = {
                init: function() {
                    f.o.yourLogo && (this.$element = a("<img>").addClass("ls-yourlogo").appendTo(c).attr("style", f.o.yourLogoStyle).css({
                        visibility: "hidden",
                        display: "bock"
                    }).on("load." + e, function() {
                        var b = f.yourLogo.$element ? 500 : 0;
                        f.timeouts.yourLogo = setTimeout(function() {
                            delete f.timeouts.yourLogo, f.yourLogo.$element.data("originalWidth", f.yourLogo.$element.width()), f.yourLogo.$element.data("originalHeight", f.yourLogo.$element.height()), "auto" != f.yourLogo.$element.css("left") && f.yourLogo.$element.data("originalLeft", f.yourLogo.$element[0].style.left), "auto" != f.yourLogo.$element.css("right") && f.yourLogo.$element.data("originalRight", f.yourLogo.$element[0].style.right), "auto" != f.yourLogo.$element.css("top") && f.yourLogo.$element.data("originalTop", f.yourLogo.$element[0].style.top), "auto" != f.yourLogo.$element.css("bottom") && f.yourLogo.$element.data("originalBottom", f.yourLogo.$element[0].style.bottom), f.o.yourLogoLink !== !1 && a("<a>").appendTo(c).attr("href", f.o.yourLogoLink).attr("target", f.o.yourLogoTarget).css({
                                textDecoration: "none",
                                outline: "none"
                            }).append(f.yourLogo.$element), f.yourLogo.$element.css({
                                display: "none",
                                visibility: "visible"
                            }), f.yourLogo.resize()
                        }, b)
                    }).attr("src", f.o.yourLogo))
                },
                resize: function() {
                    this.$element.css({
                        width: this.$element.data("originalWidth") * f.resize.ratio,
                        height: this.$element.data("originalHeight") * f.resize.ratio
                    }), this.$element.fadeIn(300);
                    var a = "auto",
                        b = "auto",
                        d = "auto",
                        e = "auto";
                    a = this.$element.data("originalLeft") && this.$element.data("originalLeft").indexOf("%") != -1 ? c.width() / 100 * parseInt(this.$element.data("originalLeft")) - this.$element.width() / 2 + parseInt(c.css("padding-left")) : parseInt(this.$element.data("originalLeft")) * f.resize.ratio, b = this.$element.data("originalRight") && this.$element.data("originalRight").indexOf("%") != -1 ? c.width() / 100 * parseInt(this.$element.data("originalRight")) - this.$element.width() / 2 + parseInt(c.css("padding-right")) : parseInt(this.$element.data("originalRight")) * f.resize.ratio, d = this.$element.data("originalTop") && this.$element.data("originalTop").indexOf("%") != -1 ? c.height() / 100 * parseInt(this.$element.data("originalTop")) - this.$element.height() / 2 + parseInt(c.css("padding-top")) : parseInt(this.$element.data("originalTop")) * f.resize.ratio, e = this.$element.data("originalBottom") && this.$element.data("originalBottom").indexOf("%") != -1 ? c.height() / 100 * parseInt(this.$element.data("originalBottom")) - this.$element.height() / 2 + parseInt(c.css("padding-bottom")) : parseInt(this.$element.data("originalBottom")) * f.resize.ratio, this.$element.css({
                        left: a,
                        right: b,
                        top: d,
                        bottom: e
                    })
                }
            }, f.gui = {
                navigation: {
                    init: function() {
                        f.o.navPrevNext && this.prevNext.init(), (f.o.navStartStop || f.o.navButtons) && this.bottom.init()
                    },
                    prevNext: {
                        init: function() {
                            a('<a class="ls-gui-element ls-nav-prev" href="#" />').on("click." + e, function(a) {
                                a.preventDefault(), c.layerSlider("prev")
                            }).appendTo(c), a('<a class="ls-gui-element ls-nav-next" href="#" />').on("click." + e, function(a) {
                                a.preventDefault(), c.layerSlider("next")
                            }).appendTo(c), f.o.hoverPrevNext && this.setHover()
                        },
                        setHover: function() {
                            c.find(".ls-nav-prev, .ls-nav-next").css({
                                display: "none"
                            }), c.on("mouseenter." + e, function() {
                                f.gui.navigation.forceHide || c.find(".ls-nav-prev, .ls-nav-next").stop(!0, !0).fadeIn(300)
                            }).on("mouseleave." + e, function() {
                                c.find(".ls-nav-prev, .ls-nav-next").stop(!0, !0).fadeOut(300)
                            })
                        }
                    },
                    bottom: {
                        init: function() {
                            this.wrapper = a('<div class="ls-gui-element ls-bottom-nav-wrapper" />').appendTo(c), f.o.navButtons && "always" != f.o.thumbnailNavigation && this.bullets.init(), f.o.navStartStop ? this.createStartStop() : "always" != f.o.thumbnailNavigation && this.createSides(), f.o.hoverBottomNav && "always" != f.o.thumbnailNavigation && this.setHover(), "always" == f.o.thumbnailNavigation && (this.wrapper.addClass("ls-above-thumbnails"), this.thumbnails.init())
                        },
                        bullets: {
                            init: function() {
                                var b = this;
                                a('<span class="ls-bottom-slidebuttons" />').appendTo(c.find(".ls-bottom-nav-wrapper"));
                                for (var d = 0; d < f.slides.count; d++) {
                                    var g = a('<a href="#" />').appendTo(c.find(".ls-bottom-slidebuttons")).data("index", d + 1).on("click." + e, function(b) {
                                        b.preventDefault(), c.layerSlider(a(this).data("index"))
                                    });
                                    "hover" == f.o.thumbnailNavigation && g.on("mouseenter." + e, function() {
                                        var d = a(this);
                                        c.find(".ls-thumbnail-hover-img").css({
                                            left: parseInt(b.hoverWrapper.css("padding-left")),
                                            top: parseInt(b.hoverWrapper.css("padding-top"))
                                        }), b.hoverImage.on("load." + e, function() {
                                            0 === a(this).width() ? b.hoverImage.css({
                                                position: "relative",
                                                margin: "0 auto",
                                                left: "auto"
                                            }) : b.hoverImage.css({
                                                position: "absolute",
                                                marginLeft: -a(this).width() / 2,
                                                left: "50%"
                                            }), b.hoverImage.css("display", "none").stop(!0, !0).fadeIn(250)
                                        }).attr("src", f.slides[d.data("index")].data.thumbnail), b.hoverWrapper.css({
                                            display: "block"
                                        }).stop().animate({
                                            left: a(this).position().left + (a(this).width() - b.hoverWrapper.outerWidth()) / 2
                                        }, 250), b.hoverWrapperInner.css({
                                            display: "none",
                                            visibility: "visible"
                                        }).stop().fadeIn(250)
                                    }).on("mouseleave." + e, function() {
                                        b.hoverWrapperInner.stop().fadeOut(250, function() {
                                            b.hoverWrapper.css({
                                                visibility: "hidden",
                                                display: "block"
                                            })
                                        })
                                    })
                                }
                                b.set.active(f.slides.first.index), "hover" == f.o.thumbnailNavigation && b.set.hover()
                            },
                            set: {
                                active: function(a) {
                                    "undefined" == typeof a && (a = f.slides.current.index), a--, c.find(".ls-bottom-slidebuttons a").removeClass("ls-nav-active"), c.find(".ls-bottom-slidebuttons a:eq( " + a + " )").addClass("ls-nav-active")
                                },
                                hover: function() {
                                    var b = f.gui.navigation.bottom.bullets,
                                        d = a('<div class="ls-thumbnail-hover"><div class="ls-thumbnail-hover-inner"><div class="ls-thumbnail-hover-bg"></div><div class="ls-thumbnail-hover-img"><img></div><span></span></div></div>').appendTo(c.find(".ls-bottom-slidebuttons"));
                                    c.find(".ls-thumbnail-hover, .ls-thumbnail-hover-img").css({
                                        width: f.o.tnWidth,
                                        height: f.o.tnHeight
                                    }), b.hoverWrapper = c.find(".ls-thumbnail-hover"), b.hoverImage = b.hoverWrapper.find("img").css({
                                        height: f.o.tnHeight
                                    }), b.hoverWrapperInner = c.find(".ls-thumbnail-hover-inner").css({
                                        visibility: "hidden",
                                        display: "block"
                                    }), d.appendTo(c.find(".ls-bottom-slidebuttons"))
                                }
                            }
                        },
                        createStartStop: function() {
                            this.buttonStart = a('<a class="ls-nav-start" href="#" />').on("click." + e, function(a) {
                                a.preventDefault(), c.layerSlider("start")
                            }).prependTo(c.find(".ls-bottom-nav-wrapper")), this.buttonStop = a('<a class="ls-nav-stop" href="#" />').on("click." + e, function(a) {
                                a.preventDefault(), c.layerSlider("stop")
                            }).appendTo(c.find(".ls-bottom-nav-wrapper")), f.o.autoStart ? this.setStartStop("start") : this.setStartStop("stop")
                        },
                        setStartStop: function(a) {
                            if (f.o.navStartStop) switch (a) {
                                case "start":
                                    this.buttonStart.addClass("ls-nav-start-active"), this.buttonStop.removeClass("ls-nav-stop-active");
                                    break;
                                case "stop":
                                    this.buttonStart.removeClass("ls-nav-start-active"), this.buttonStop.addClass("ls-nav-stop-active")
                            }
                        },
                        createSides: function() {
                            a('<span class="ls-nav-sides ls-nav-sideleft" />').prependTo(c.find(".ls-bottom-nav-wrapper")), a('<span class="ls-nav-sides ls-nav-sideright" />').appendTo(c.find(".ls-bottom-nav-wrapper"))
                        },
                        setHover: function() {
                            var a = this;
                            a.wrapper.css({
                                display: "none"
                            }), c.on("mouseenter." + e, function() {
                                f.gui.navigation.forceHide || a.wrapper.stop(!0, !0).fadeIn(300)
                            }).on("mouseleave." + e, function() {
                                a.wrapper.stop(!0, !0).fadeOut(300)
                            })
                        },
                        switchHelper: function(a) {
                            if (f.o.hoverBottomNav && !c.hasClass("ls-hover")) switch (a) {
                                case "on":
                                    f.gui.navigation.bottom.thumbnails.wrapper.css({
                                        visibility: "hidden",
                                        display: "block"
                                    });
                                    break;
                                case "off":
                                    f.gui.navigation.bottom.thumbnails.wrapper.css({
                                        visibility: "visible",
                                        display: "none"
                                    })
                            }
                        },
                        thumbnails: {
                            init: function() {
                                var b = this;
                                this.wrapper = a('<div class="ls-gui-element ls-thumbnail-wrapper"></div>').appendTo(c), a('<div class="ls-thumbnail"><div class="ls-thumbnail-inner"><div class="ls-thumbnail-slide-container"><div class="ls-thumbnail-slide"></div></div></div></div>').appendTo(this.wrapper), this.$element = c.find(".ls-thumbnail-slide-container"), "ontouchstart" in window ? this.$element.addClass("ls-touchscroll") : this.$element.on("mouseenter." + e, function() {
                                    a(this).addClass("ls-thumbnail-slide-hover")
                                }).on("mouseleave." + e, function() {
                                    a(this).removeClass("ls-thumbnail-slide-hover"), f.gui.navigation.bottom.thumbnails.scroll()
                                }).on("mousemove." + e, function(b) {
                                    var c = parseInt(b.pageX - a(this).offset().left) / a(this).width() * (a(this).width() - a(this).find(".ls-thumbnail-slide").width());
                                    a(this).find(".ls-thumbnail-slide").stop().css({
                                        marginLeft: c
                                    })
                                });
                                for (var d = 0; d < f.slides.count; d++) {
                                    var g = d + 1,
                                        h = a('<a href="#" class="ls-thumb-' + (d + 1) + '"><img src="' + f.slides[g].data.thumbnail + '"></a>');
                                    h.data("index", g).on("click." + e, function(b) {
                                        b.preventDefault(), c.layerSlider(a(this).data("index"))
                                    }).appendTo(c.find(".ls-thumbnail-slide")), "ontouchstart" in window || h.on("mouseenter." + e, function() {
                                        a(this).children().stop().fadeTo(300, f.o.tnActiveOpacity / 100)
                                    }).on("mouseleave." + e, function() {
                                        a(this).children().hasClass("ls-thumb-active") || a(this).children().stop().fadeTo(300, f.o.tnInactiveOpacity / 100)
                                    })
                                }
                                f.gui.navigation.bottom.buttonStart && f.gui.navigation.bottom.buttonStop && (f.gui.navigation.bottom.wrapper = a('<div class="ls-bottom-nav-wrapper ls-below-thumbnails"></div>').appendTo(c), f.gui.navigation.bottom.buttonStart.clone().on("click." + e, function(a) {
                                    a.preventDefault(), c.layerSlider("start")
                                }).appendTo(f.gui.navigation.bottom.wrapper), f.gui.navigation.bottom.buttonStop.clone().on("click." + e, function(a) {
                                    a.preventDefault(), c.layerSlider("stop")
                                }).appendTo(f.gui.navigation.bottom.wrapper)), f.o.hoverBottomNav && b.setHover()
                            },
                            setHover: function() {
                                var a = this;
                                a.wrapper.css("display", "none"), f.gui.navigation.bottom.wrapper && (f.gui.navigation.bottom.wrapper = "block" == f.gui.navigation.bottom.wrapper.css("display") ? f.gui.navigation.bottom.wrapper : c.find(".ls-above-thumbnails"), f.gui.navigation.bottom.wrapper.css("display", "none")), c.on("mouseenter." + e, function() {
                                    c.addClass("ls-hover"), f.gui.navigation.forceHide || (a.wrapper.stop(!0, !0).fadeIn(300), f.gui.navigation.bottom.wrapper && f.gui.navigation.bottom.wrapper.stop(!0, !0).fadeIn(300))
                                }).on("mouseleave." + e, function() {
                                    c.removeClass("ls-hover"), a.wrapper.stop(!0, !0).fadeOut(300), f.gui.navigation.bottom.wrapper && f.gui.navigation.bottom.wrapper.stop(!0, !0).fadeOut(300)
                                })
                            },
                            change: function(b) {
                                var d = b ? b : f.slides.next.index;
                                c.find(".ls-thumbnail-slide a:not(.ls-thumb-" + d + " )").children().each(function() {
                                    a(this).removeClass("ls-thumb-active").stop().fadeTo(750, f.o.tnInactiveOpacity / 100)
                                }), c.find(".ls-thumbnail-slide a.ls-thumb-" + d).children().addClass("ls-thumb-active").stop().fadeTo(750, f.o.tnActiveOpacity / 100)
                            },
                            scroll: function() {
                                if (!c.find(".ls-thumbnail-slide-container").hasClass("ls-thumbnail-slide-hover")) {
                                    var a = !!c.find(".ls-thumb-active").length && c.find(".ls-thumb-active").parent();
                                    if (a) {
                                        var b = a.position().left + a.width() / 2,
                                            d = c.find(".ls-thumbnail-slide-container").width() / 2 - b;
                                        d = d < c.find(".ls-thumbnail-slide-container").width() - c.find(".ls-thumbnail-slide").width() ? c.find(".ls-thumbnail-slide-container").width() - c.find(".ls-thumbnail-slide").width() : d, d = d > 0 ? 0 : d, c.find(".ls-thumbnail-slide").animate({
                                            marginLeft: d
                                        }, 600)
                                    }
                                }
                            },
                            resize: function() {
                                f.gui.navigation.bottom.switchHelper("on");
                                var a = f.slider.initial.width.indexOf("%") == -1 ? parseInt(f.slider.initial.originalWidth) : c.width(),
                                    b = c.find(".ls-thumbnail"),
                                    d = f.o.tnContainerWidth.indexOf("%") == -1 ? parseInt(f.o.tnContainerWidth) : parseInt(a / 100 * parseInt(f.o.tnContainerWidth));
                                c.find(".ls-thumbnail-slide a").css({
                                    width: parseInt(f.o.tnWidth * f.resize.ratio),
                                    height: parseInt(f.o.tnHeight * f.resize.ratio)
                                }), c.find(".ls-thumbnail-slide a:last").css({
                                    margin: 0
                                }), c.find(".ls-thumbnail-slide").css({
                                    height: parseInt(f.o.tnHeight * f.resize.ratio)
                                }), b.css({
                                    width: d * Math.floor(100 * f.resize.ratio) / 100
                                }), b.width() > c.find(".ls-thumbnail-slide").width() && b.css({
                                    width: c.find(".ls-thumbnail-slide").width()
                                }), f.gui.navigation.bottom.switchHelper("off")
                            }
                        }
                    }
                },
                skin: {
                    load: function() {
                        c.addClass("ls-" + f.o.skin);
                        var g, b = f.o.skinsPath + f.o.skin + "/skin.css",
                            d = a(a("head").length ? "head" : "body");
                        a('link[href="' + b + '"]').length ? (g = a('link[href="' + b + '"]'), f.gui.skin.isLoaded || (f.gui.skin.isLoaded = !0, f.timeouts.skinLoad1 = setTimeout(function() {
                            delete f.timeouts.skinLoad1, f.slider.init()
                        }, 150))) : document.createStyleSheet ? (document.createStyleSheet(b), g = a('link[href="' + b + '"]')) : g = a('<link rel="stylesheet" href="' + b + '" type="text/css" />').appendTo(d), g.on("load." + e, function() {
                            f.gui.skin.isLoaded || (f.gui.skin.isLoaded = !0, f.timeouts.skinLoad2 = setTimeout(function() {
                                delete f.timeouts.skinLoad2, f.slider.init()
                            }, 150))
                        }), a(window).on("load." + e, function() {
                            f.gui.skin.isLoaded || (f.gui.skin.isLoaded = !0, f.timeouts.skinLoad3 = setTimeout(function() {
                                delete f.timeouts.skinLoad3, f.slider.init()
                            }, 150))
                        }), f.timeouts.skinLoad4 = setTimeout(function() {
                            f.gui.skin.isLoaded || (f.gui.skin.isLoaded = !0, delete f.timeouts.skinLoad4, f.slider.init())
                        }, 1e3)
                    }
                },
                shadow: {
                    init: function() {
                        this.set(), this.resize()
                    },
                    set: function() {
                        this.$element = a('<div class="ls-gui-element ls-shadow"></div>').appendTo(c), "block" != this.$element.css("display") || this.$element.find("img").length || (this.show = function() {
                            f.gui.shadow.$element.css({
                                display: "none",
                                visibility: "visible"
                            }).fadeIn(500, function() {
                                f.gui.shadow.show = !1
                            })
                        }, this.image = a("<img>").attr("src", f.o.skinsPath + f.o.skin + "/shadow.png").appendTo(this.$element), this.btmMod = "number" == typeof parseInt(c.css("padding-bottom")) ? parseInt(c.css("padding-bottom")) : 0)
                    },
                    resize: function() {
                        this.image && (this.image.height() > 0 ? this.btmMod > 0 ? this.$element.css({
                            height: this.image.height() / 2
                        }) : this.$element.css({
                            height: this.image.height(),
                            marginTop: -this.image.height() / 2
                        }) : f.timeouts.resizeShadow = setTimeout(function() {
                            delete f.timeouts.resizeShadow, f.gui.shadow.resize()
                        }, 50))
                    }
                },
                timers: {
                    init: function() {
                        f.o.showBarTimer && this.bar.create(), f.o.showCircleTimer && this.circle.create();
                        var b = !1;
                        b = f.o.showSlideBarTimer ? a("<div>").insertAfter(c) : a('[data-slidebar-for="' + c.attr("id") + '"], [data-slidebar-for="' + e + '"]'), b.length && (b.addClass("ls-gui-element"), this.slidebar.create(b))
                    },
                    bar: {
                        create: function() {
                            this.$element = a("<div>").addClass("ls-gui-element ls-bar-timer").appendTo(c)
                        }
                    },
                    circle: {
                        create: function() {
                            this.$element = a("<div>").addClass("ls-gui-element ls-circle-timer").appendTo(c), this.$element.append(a('<div class="ls-ct-center"></div><div class="ls-ct-left"><div class="ls-ct-rotate"><div class="ls-ct-hider"><div class="ls-ct-half"></div></div></div></div><div class="ls-ct-right"><div class="ls-ct-rotate"><div class="ls-ct-hider"><div class="ls-ct-half"></div></div></div></div>')), this.$element.data("original", {
                                opacity: this.$element.css("opacity")
                            })
                        }
                    },
                    slidebar: {
                        $containerElement: [],
                        $element: [],
                        $progressBarElement: [],
                        $sliderContainerElement: [],
                        $sliderElement: [],
                        elementWidth: [],
                        containerElementWidth: [],
                        sliderContainerElementWidth: [],
                        create: function(b) {
                            var g, d = a(document),
                                h = this,
                                i = function(a, b) {
                                    g = (a.pageX ? a.pageX : f.device.touchX) - h.$element[b].offset().left - h.sliderContainerElementWidth[b] / 2, g < 0 && (g = 0), g > h.containerElementWidth[b] - h.sliderContainerElementWidth[b] && (g = "calc( 100% - " + f.gui.timers.slidebar.sliderContainerElementWidth[b] + "px )"), h.$sliderContainerElement[b].css({
                                        left: g
                                    }), f.transitions._slideTimeline && f.transitions._slideTimeline.progress("string" == typeof g ? f.transitions.layers.timeline.progress : g / (h.containerElementWidth[b] - h.sliderContainerElementWidth[b]) * f.transitions.layers.timeline.progress)
                                },
                                j = function(b, c) {
                                    a(document).off("mousemove." + e), a("body").prop("unselectable", !1).removeClass("ls-unselectable"), f.o.pauseLayers && !f.slideshow.state.running || f.slider.isPaused || !f.transitions._slideTimeline || f.o.playByScroll || (f.transitions.layers.timeline.state.started === !0 ? f.transitions.layers.timeline.resume() : f.transitions.layers.timeline.play())
                                };
                            a.each(b, function(b, c) {
                                h.$containerElement[b] = a(c).addClass("ls-slidebar-container " + e), h.$element[b] = a("<div>").addClass("ls-slidebar").appendTo(h.$containerElement[b]), h.$progressBarElement[b] = a("<div>").addClass("ls-progressbar").appendTo(h.$element[b]), h.$sliderContainerElement[b] = a("<div>").addClass("ls-slidebar-slider-container").appendTo(h.$containerElement[b]), h.$sliderElement[b] = a("<div>").addClass("ls-slidebar-slider").appendTo(h.$sliderContainerElement[b]), h.sliderContainerElementWidth[b] = h.$sliderContainerElement[b].width(), h.$sliderContainerElement[b].css({
                                    marginTop: -h.$sliderElement[b].outerHeight() / 2
                                }), h.$containerElement[b].on("touchmove." + e, function(a) {
                                    i(a, b)
                                }), h.$containerElement[b].on("mousedown." + e + " touchstart." + e, function(c) {
                                    f.transitions.layers.timeline.pause(0), a("body").prop("unselectable", !0).addClass("ls-unselectable"), a(document).on("mousemove." + e, function(a) {
                                        i(a, b)
                                    }), i(c, b)
                                }), d = d.add(h.$sliderElement[b])
                            }), d.on("mouseup." + e + "touchend." + e, function(b) {
                                a(b.target).closest(c).length || (f.transitions._slideTimeline && f.transitions.layers.timeline.state.finished && f.transitions._slideTimeline.progress() !== f.transitions.layers.timeline.progress && f.functions.setStates(f.transitions.layers.timeline, {
                                    finished: !1
                                }), j(b))
                            })
                        }
                    }
                },
                loadingIndicator: {
                    init: function() {
                        this.$element = a("<div>").css({
                            display: "none"
                        }).addClass("ls-gui-element ls-loading-container").appendTo(c), a("<div>").addClass("ls-loading-indicator").appendTo(this.$element)
                    },
                    show: function() {
                        this.$element.delay(400).fadeIn(300)
                    },
                    hide: function() {
                        this.$element.stop(!0, !0).fadeOut(300)
                    }
                }
            }, f.navigation = {
                direction: "next",
                init: function() {
                    f.slides.count > 1 && (this.set.keyboard(), this.set.touch())
                },
                set: {
                    keyboard: function() {
                        f.o.keybNav && a("body").on("keydown." + e, function(a) {
                            f.slider.isAnimating || f.slider.isPreloading || (37 == a.which ? f.navigation.prev() : 39 == a.which && f.navigation.next())
                        })
                    },
                    touch: function() {
                        "ontouchstart" in window && f.o.touchNav && (f.slider.$innerWrapper.on("touchstart." + e, function(a) {
                            var b = a.touches ? a.touches : a.originalEvent.touches;
                            1 == b.length && (f.device.touchStartX = f.device.touchEndX = b[0].clientX)
                        }), f.slider.$innerWrapper.on("touchmove." + e, function(a) {
                            var b = a.touches ? a.touches : a.originalEvent.touches;
                            1 == b.length && (f.device.touchEndX = b[0].clientX), Math.abs(f.device.touchStartX - f.device.touchEndX) > 45 && a.preventDefault()
                        }), f.slider.$innerWrapper.on("touchend." + e, function(a) {
                            Math.abs(f.device.touchStartX - f.device.touchEndX) > 45 && (f.device.touchStartX - f.device.touchEndX > 0 ? c.layerSlider("touchNext") : c.layerSlider("touchPrev"))
                        }))
                    }
                },
                prev: function() {
                    this.direction = "prev", this.forceDirection = "prev", f.slideshow.set.prevNext("prev")
                },
                next: function() {
                    this.direction = "next", this.forceDirection = "next", f.slideshow.set.prevNext("next")
                },
                start: function() {
                    f.functions.setStates(f.slideshow, {
                        running: !0,
                        paused: !1
                    }), f.slideshow.state.pausedByLastCycle === !0 && f.functions.setStates(f.slideshow, {
                        pausedByLastCycle: !1
                    }), f.gui.navigation.bottom.setStartStop("start"), f.slideshow.state.pausedByHover || 1 !== f.transitions._slideTimeline.timeScale() && f.transitions.layers.timeline.resume(), f.slideshow.start()
                },
                stop: function() {
                    f.gui.navigation.bottom.setStartStop("stop"), f.o.pauseLayers && f.transitions.layers.timeline.pause(), f.slideshow.stop()
                }
            }, f.preload = {
                init: function() {
                    f.slider.$hiddenWrapper.find(".ls-slide img").each(function() {
                        var b = a(this),
                            c = b[0],
                            d = {};
                        if (b.is(".ls-layer, .ls-bg")) {
                            if (c.getAttribute("width") && (d.width = c.getAttribute("width")), c.getAttribute("height") && (d.height = c.getAttribute("height")), c.sizes && (d.sizes = c.sizes), c.srcset && f.o.useSrcset) {
                                d.srcSet = c.srcset, d.curSrc = c.currentSrc;
                                var e = d.srcSet.split(",").map(function(b) {
                                    return parseInt(a.trim(b).split(" ")[1])
                                });
                                d.maxWidth = Math.max.apply(null, e)
                            }
                            b.removeAttr("width").removeAttr("height").removeAttr("sizes").removeAttr("srcset"), a.isEmptyObject(d) || (b.data(f.defaults.init.dataKey).attributes = d)
                        }
                        b.data("src") ? d.curSrc && b.data("src", d.curSrc) : b.data("src", d.curSrc ? d.curSrc : c.src), b.attr("src", "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7")
                    })
                },
                imagesOfSlide: function(b, d) {
                    if (f.slides[b].wrapped !== !0) {
                        this.slideIndex = b, d ? (this.onCompleteCallback = d, f.functions.setStates(f.slider, {
                            preloadingImages: !0
                        }), f.gui.loadingIndicator.show()) : this.onCompleteCallback = !1, f.slider.canShow && c.css({
                            visibility: "visible"
                        }), this.preImages = [];
                        var g, h, e = this;
                        f.slider.$hiddenWrapper.find(".ls-slide:eq(" + (e.slideIndex - 1) + ") *").each(function() {
                            g = a(this), h = this;
                            var b = g.data(f.defaults.init.dataKey);
                            if (g.is("img")) {
                                g.data("src") && g.attr("src", g.data("src")), b && b.attributes && b.attributes.srcSet && f.o.useSrcset && (h.srcset = b.attributes.srcSet);
                                var c = h.src,
                                    d = !!(b && b.attributes && b.attributes.curSrc) && b.attributes.curSrc;
                                d && c !== d && g.is(".ls-bg") && (c = d, f.slides[e.slideIndex].data.$background.attr("src", c)), f.preload.preImages.push([c, g])
                            } else "none" !== g.css("background-image") && g.css("background-image").indexOf("url") !== -1 && f.preload.preImages.push([g.css("background-image").match(/url\((.*)\)/)[1].replace(/"/gi, ""), g])
                        }), f.transitions.firstSlide && f.o.globalBGImage && f.preload.preImages.push([f.o.globalBGImage, a()]), this.thumbnailsAreLoaded || this.thumbnails(), 0 === this.preImages.length ? this.onComplete() : this.start()
                    } else f.slider.shouldResize && d && (f.resize.setLayers(f.layers.get("next, bg")), f.resize.layers(d))
                },
                thumbnails: function() {
                    for (var a = f.slider.thumbnails.filter(function(a, b, c) {
                            return c.indexOf(a) == b
                        }), b = a.length, c = 0; c < b; c++) {
                        var d = new Image;
                        d.src = a[c]
                    }
                    this.thumbnailsAreLoaded = !0
                },
                start: function() {
                    f.debugMode && (f.debug.add("group", "preload"), f.debug.add("log", "preload.info", this.slideIndex)), this.preloadedImagesCount = 0;
                    for (var b, a = this, c = function() {
                            ++a.preloadedImagesCount == a.preImages.length && (f.debugMode && f.debug.groupEnd(), a.onComplete())
                        }, d = function() {
                            f.debugMode && (b = this.src.substring(this.src.lastIndexOf("/") + 1, this.src.length), f.debug.add("log", "preload.success", b)), this.originalLayer.data("preloadedWidth", this.width), this.originalLayer.data("preloadedHeight", this.height), c()
                        }, e = function() {
                            f.debugMode && (b = this.src.substring(this.src.lastIndexOf("/") + 1, this.src.length), f.debug.add("warn", "preload.fail", b)), c()
                        }, g = 0; g < this.preImages.length; g++) {
                        var h = new Image;
                        h.addEventListener("error", e, !1), h.addEventListener("load", d, !1), h.src = this.preImages[g][0], h.originalLayer = this.preImages[g][1]
                    }
                },
                onComplete: function() {
                    var b = this;
                    this.onCompleteCallback ? (f.layers.wrap(this.slideIndex), function c() {
                        if (0 !== f.slides[b.slideIndex].$layers.length) f.timeouts.waitForWrap = setTimeout(c, 100);
                        else {
                            delete f.timeouts.waitForWrap, f.functions.setStates(f.transitions.layers.parallax, {
                                ready: !0
                            }), a(".ls-thumbnail-wrapper, .ls-nav-next, .ls-nav-prev, .ls-bottom-nav-wrapper").css({
                                visibility: "visible"
                            }), f.slides[b.slideIndex].wrapped = !0;
                            var d = !(!window._layerSlider.globals.youTubeIsReady && f.layers.get("next,in,youtube,bgvideo").length),
                                e = !(!window._layerSlider.globals.vimeoIsReady && f.layers.get("next,in,vimeo,bgvideo").length),
                                g = function() {
                                    f.gui.loadingIndicator.hide(), f.slider.shouldResize ? (f.resize.setLayers(f.layers.get("next, bg")), f.resize.layers(b.onCompleteCallback)) : b.onCompleteCallback()
                                };
                            d && e ? g() : f.intervals.waitForJSApisLoaded = setInterval(function() {
                                (d || window._layerSlider.globals.youTubeIsReady) && (e || window._layerSlider.globals.vimeoIsReady) && (clearInterval(f.intervals.waitForJSApisLoaded), delete f.intervals.waitForJSApisLoaded, g())
                            }, 50)
                        }
                    }()) : f.layers.wrap(this.slideIndex, !0), f.functions.setStates(f.slider, {
                        preloadingImages: !1
                    })
                }
            }, f.resize = {
                setLayers: function(a) {
                    this.$responsiveLayers = a.add(f.layers.get("active")), f.slides.next.data.$backgroundVideo.length && (this.$responsiveLayers = this.$responsiveLayers.add(f.slides.next.data.$backgroundVideo))
                },
                all: function() {
                    return !!document.body.contains(b) && (f.api.hasEvent("sliderWillResize") && c.triggerHandler("sliderWillResize", f.api.eventData()), this.slider(), this.navigation(), this.layers(), this.yourLogo(), this.shadow(), this.timers(), f.transitions.layers.timeline.shouldRestart && f.o.allowRestartOnResize && (f.functions.resetSlideTimelines(), f.transitions.layers.timeline.create(!0)), void(f.api.hasEvent("sliderDidResize") && c.triggerHandler("sliderDidResize", f.api.eventData())))
                },
                viewport: function() {
                    a(window).scrollTop(Math.round(f.slider.offsetTop) - (f.device.viewportHeight - f.slider.height) / 2)
                },
                slider: function() {
                    if (!document.body.contains(b)) return !1;
                    var h, j, d = f.slider.$parentWithNumericWidthValue ? f.slider.$parentWithNumericWidthValue : f.functions.getSliderClosestParentElementWidthNumericValueOfProperty("width"),
                        e = f.slider.initial,
                        g = f.slider.$parentWithNumericWidthValuePercent ? d.width() / 100 * f.slider.$parentWithNumericWidthValuePercent : d.width(),
                        i = e.type,
                        k = 0 !== e.maxWidth ? e.maxWidth : g,
                        l = "auto" === e.marginLeft ? 0 : e.marginLeft,
                        m = "auto" === e.marginRight ? 0 : e.marginRight;
                    if (f.slider.state.inFullscreen ? c[0].style.maxWidth = "" : 0 !== e.maxWidth && (c[0].style.maxWidth = e.maxWidth + "px"), k.indexOf("%") !== -1 && (k = g / 100 * parseInt(k)), g -= l + m, g > k && k >= 0 && (g = k), f.o.fitScreenWidth && ("fullwidth" === i || "fullsize" === i && "fitheight" !== f.o.fullSizeMode)) {
                        var o = (c.parent(), d.offset().left),
                            p = parseInt(d.css("padding-left")) || 0,
                            q = parseInt(d.css("border-left-width")) || 0;
                        c[0].style.maxWidth = "none", c[0].style.marginLeft = -(o + p + q) + "px", g = f.device.viewportWidth || a(window).width()
                    }
                    switch (g -= e.skinWidth, f.slider.state.inFullscreen && (g = f.device.width), i) {
                        case "responsive":
                            f.slider.state.inFullscreen ? (f.device.ratio > e.ratio ? this.ratio = f.device.height / e.height : this.ratio = f.device.width / e.width, g = Math.round(e.width * this.ratio), h = Math.round(e.height * this.ratio)) : (this.ratio = g / e.width, h = Math.round(e.height * this.ratio));
                            break;
                        case "fullwidth":
                            g < f.o.responsiveUnder ? (this.ratio = g / f.o.responsiveUnder, h = Math.round(e.height * this.ratio)) : f.slider.state.inFullscreen ? f.device.ratio > e.layersWidth / e.height ? (this.ratio = f.device.height / e.height, h = f.device.height) : (this.ratio = f.device.width / e.layersWidth, h = e.height * this.ratio) : (this.ratio = 1, h = e.height);
                            break;
                        case "fullsize":
                            switch (f.o.fullSizeMode.toLowerCase()) {
                                case "normal":
                                    h = f.device.viewportHeight - e.skinHeight;
                                    break;
                                case "hero":
                                    h = f.device.viewportHeight - e.skinHeight, f.slider.state.inFullscreen || (h -= f.slider.heroTop ? f.slider.heroTop : f.slider.offsetTop);
                                    break;
                                case "fitheight":
                                    g = c.parent().width() - e.skinWidth, h = c.parent().height() - e.skinHeight
                            }
                            j = g / h, j < e.ratio ? this.ratio = g / e.layersWidth : this.ratio = h / e.layersHeight;
                            break;
                        case "fixed":
                        case "fixedsize":
                            this.ratio = 1, g = e.width, h = e.height, f.o.maxRatio = 1, b.style.maxWidth = "none"
                    }
                    this.ratio = f.o.maxRatio && f.o.maxRatio > 0 && this.ratio > f.o.maxRatio ? f.o.maxRatio : this.ratio, b.style.width = g + "px", b.style.height = h + "px", f.slider.width = g, f.slider.height = h, f.device.isMobile ? f.device.viewportWidth < 1025 && f.device.viewportWidth > 767 ? c.removeClass("ls-device-is-phone").addClass("ls-device-is-tablet") : f.device.viewportWidth < 768 && c.removeClass("ls-device-is-tablet").addClass("ls-device-is-phone") : c.removeClass("ls-device-is-phone ls-device-is-tablet").addClass("ls-device-is-desktop")
                },
                borderRadius: function(b) {
                    for (var c = ("" + b).split(" "), d = "", e = f.o.maxRatio && f.o.maxRatio > 0 && this.ratio > f.o.maxRatio ? f.o.maxRatio : this.ratio, g = 0, h = c.length; g < h; g++) d += c[g].indexOf("%") === -1 ? Math.ceil(parseInt(c[g]) * e) + "px " : c[g] + " ";
                    return a.trim(d)
                },
                layers: function(b) {
                    if (this.$responsiveLayers) {
                        f.debugMode && f.debug.add("group", "resize");
                        var c = this,
                            d = this.ratio,
                            e = this.$responsiveLayers,
                            g = f.slider.initial,
                            h = f.slider.width,
                            i = f.slider.height,
                            j = h / i,
                            k = [],
                            l = [],
                            m = [],
                            n = [],
                            o = 0,
                            p = 0,
                            q = "responsive" === g.type && f.o.maxRatio !== -1 ? g.width : g.layersWidth,
                            r = "responsive" === g.type && f.o.maxRatio !== -1 ? g.height : g.layersHeight;
                        "fullsize" === g.type || "fullwidth" === g.type || "responsive" === g.type ? (o = q > 0 ? (h - q * d) / 2 : 0, p = r > 0 ? (i - r * d) / 2 : 0) : (o = o < 0 ? 0 : o, p = p < 0 ? 0 : p);
                        for (var s = 0, t = e.length; s < t; s++) {
                            var y, z, A, u = a(e[s]),
                                w = (e[s], u.data(f.defaults.init.dataKey)),
                                x = w.original,
                                B = "fixed" === w.settings.position,
                                C = B ? 0 : o,
                                D = B ? 0 : p,
                                E = {
                                    width: B && 0 !== x.percentWidth ? h / 100 * x.percentWidth : x.width * d,
                                    height: B && 0 !== x.percentHeight ? i / 100 * x.percentHeight : x.height * d,
                                    paddingLeft: x.paddingLeft * d,
                                    paddingTop: x.paddingTop * d,
                                    paddingRight: x.paddingRight * d,
                                    paddingBottom: x.paddingBottom * d,
                                    borderLeftWidth: Math.ceil(x.borderLeftWidth * d),
                                    borderTopWidth: Math.ceil(x.borderTopWidth * d),
                                    borderRightWidth: Math.ceil(x.borderRightWidth * d),
                                    borderBottomWidth: Math.ceil(x.borderBottomWidth * d),
                                    borderRadius: this.borderRadius(x.borderRadius)
                                },
                                F = {
                                    marginLeft: x.marginLeft * d,
                                    marginTop: x.marginTop * d
                                },
                                G = {},
                                H = {
                                    borderRadius: E.borderRadius
                                };
                            if (B && (x.percentHeight || x.percentWidth) && w.is.imageLayer && (x.percentHeight && !x.percentWidth && (E.width = x.width * (E.height / x.height)), x.percentWidth && !x.percentHeight && (E.height = x.height * (E.width / x.width))), ("number" == typeof x.width && x.width < 0 || "auto" == x.width) && f.debugMode && f.debug.add("warn", "resize.width", [s + 1, x.width]), ("number" == typeof x.height && x.height < 0 || "auto" == x.height) && f.debugMode && f.debug.add("warn", "resize.height", [s + 1, x.height]), w.is.textLayer && (E.fontSize = x.fontSize * d, f.device.isMobile && E.fontSize < w.styleSettings.minmobilefontsize ? E.fontSize = w.styleSettings.minmobilefontsize : E.fontSize < w.styleSettings.minfontsize && (E.fontSize = w.styleSettings.minfontsize), A = E.fontSize / x.fontSize, E.fontSize += "px", "normal" !== x.lineHeight && (E.lineHeight = parseFloat(x.lineHeight) * A + "px"), "normal" !== x.letterSpacing && (E.letterSpacing = parseFloat(x.letterSpacing) * A + "px")), w.is.slideBackground || w.is.backgroundVideo)
                                if (w.is.slideBackground) {
                                    var I = f.slides[w.is.onSlide].data.backgroundSize;
                                    switch (y = "undefined" != typeof I && "inherit" !== I ? I : f.o.slideBGSize, y.replace("100% 100%", "stretch"), y) {
                                        case "auto":
                                            break;
                                        case "cover":
                                            x.ratio < j ? (E.width = h, E.height = E.width / x.ratio) : (E.height = i, E.width = E.height * x.ratio);
                                            break;
                                        case "contain":
                                            x.ratio < j ? (E.height = i, E.width = E.height * x.ratio) : (E.width = h, E.height = E.width / x.ratio);
                                            break;
                                        case "stretch":
                                            E.width = h, E.height = i
                                    }
                                    E.width = Math.round(E.width), E.height = Math.round(E.height);
                                    var J = f.slides[w.is.onSlide].data.backgroundPosition;
                                    switch (z = "undefined" != typeof J ? J.split(" ") : f.o.slideBGPosition.split(" "), z[0]) {
                                        case "left":
                                            E.x = 0;
                                            break;
                                        case "center":
                                            E.x = (f.slider.width - E.width) / 2;
                                            break;
                                        case "right":
                                            E.x = f.slider.width - E.width;
                                            break;
                                        default:
                                            z[0].indexOf("%") !== -1 ? E.x = (f.slider.width - E.width) / 100 * parseInt(z[0]) : E.x = parseInt(z[0])
                                    }
                                    if ("undefined" != typeof z[1]) switch (z[1]) {
                                        case "top":
                                            E.y = 0;
                                            break;
                                        case "center":
                                            E.y = (f.slider.height - E.height) / 2;
                                            break;
                                        case "bottom":
                                            E.y = f.slider.height - E.height;
                                            break;
                                        default:
                                            z[1].indexOf("%") !== -1 ? E.y = (f.slider.height - E.height) / 100 * parseInt(z[1]) : E.y = parseInt(z[1])
                                    }
                                    E.transform = "translateX(" + E.x + "px) translateY(" + E.y + "px)", E["-ms-transform"] = "translateX(" + E.x + "px) translateY(" + E.y + "px)", E["-webkit-transform"] = "translateX(" + E.x + "px) translateY(" + E.y + "px)"
                                } else w.is.backgroundVideo && (x.ratio < j ? (E.width = h, E.height = E.width / x.ratio) : (E.height = i, E.width = E.height * x.ratio), E.x = (f.slider.width - E.width) / 2, E.y = (f.slider.height - E.height) / 2, E.width = Math.round(E.width), E.height = Math.round(E.height), E.transform = "translateX(" + E.x + "px) translateY(" + E.y + "px)", E["-ms-transform"] = "translateX(" + E.x + "px) translateY(" + E.y + "px)", E["-webkit-transform"] = "translateX(" + E.x + "px) translateY(" + E.y + "px)");
                            else {
                                if (w.mediaSettings.fullsize) switch (w.mediaSettings.fillmode) {
                                    default:
                                        case "cover":
                                        x.ratio < j ? (E.width = h, E.height = E.width / x.ratio) : (E.height = i, E.width = E.height * x.ratio);
                                    break;
                                    case "contain":
                                            x.ratio > j ? (E.width = h, E.height = E.width / x.ratio) : (E.height = i, E.width = E.height * x.ratio)
                                }
                                E.outerWidth = E.width + E.paddingLeft + E.paddingRight + E.borderLeftWidth + E.borderRightWidth, E.outerHeight = E.height + E.paddingTop + E.paddingBottom + E.borderTopWidth + E.borderBottomWidth, F.width = G.width = E.outerWidth, F.height = G.height = E.outerHeight, x.left.indexOf("%") != -1 ? "100%" === x.left ? 0 === C ? E.left = f.slider.width / 100 * parseInt(x.left) - E.outerWidth : E.left = C + q * d / 100 * parseInt(x.left) - E.outerWidth : "0%" === x.left ? 0 === C ? E.left = 0 : E.left = C : 0 === C ? E.left = f.slider.width / 100 * parseInt(x.left) - E.outerWidth / 2 : E.left = C + q * d / 100 * parseInt(x.left) - E.outerWidth / 2 : E.left = C + parseInt(x.left) * d, F.left = E.left, x.top.indexOf("%") != -1 ? "100%" === x.top ? 0 === D ? E.top = f.slider.height / 100 * parseInt(x.top) - E.outerHeight : E.top = D + r * d / 100 * parseInt(x.top) - E.outerHeight : "0%" === x.top ? 0 === D ? E.top = 0 : E.top = D + 0 : 0 === D ? E.top = f.slider.height / 100 * parseInt(x.top) - E.outerHeight / 2 : E.top = D + r * d / 100 * parseInt(x.top) - E.outerHeight / 2 : E.top = D + parseInt(x.top) * d, F.top = E.top
                            }
                            w.responsive = E, k[s] = E, w.is.slideBackground || w.is.backgroundVideo || (w.settings.wrapperData.responsive = F, l[s] = F, m[s] = G, n[s] = H)
                        }
                        for (var K = 0, L = k.length; K < L; K++) {
                            var M = a(e[K]),
                                N = M.data(f.defaults.init.dataKey);
                            M.css(k[K]), N.is.slideBackground || N.is.backgroundVideo ? (N.is.slideBackground || N.is.backgroundVideo) && (N.elements.$bgOuterWrapper.css({
                                width: f.slider.width,
                                height: f.slider.height
                            }), N.elements.$outerWrapper.css({
                                width: f.slider.width,
                                height: f.slider.height
                            })) : (M.find(".split-item").css(n[K]), c.wrappers(M, N, l[K], m[K]))
                        }
                        "undefined" != typeof b && b(), f.debugMode && f.debug.groupEnd("resize")
                    }
                },
                wrappers: function(a, b, c, d) {
                    c && b.elements.$wrapper.css(c), d && b.loop.enabled && b.elements.$loopWrapper.css(d), g.TweenMax.set(b.elements.$wrapper[0], {
                        autoCSS: !1,
                        css: {
                            transformPerspective: b.transformPerspective.layer * f.resize.ratio
                        }
                    }), b.loop.enabled && g.TweenMax.set(b.elements.$loopWrapper[0], {
                        autoCSS: !1,
                        css: {
                            transformPerspective: b.transformPerspective.loop * f.resize.ratio
                        }
                    }), b.hover.enabled && g.TweenMax.set(a[0], {
                        autoCSS: !1,
                        css: {
                            transformPerspective: b.transformPerspective.hover * f.resize.ratio
                        }
                    }), b.textIn.nodes && g.TweenMax.set(b.textIn.nodes, {
                        autoCSS: !1,
                        css: {
                            transformPerspective: b.transformPerspective.text * f.resize.ratio
                        }
                    }), b.textOut.nodes && g.TweenMax.set(b.textOut.nodes, {
                        autoCSS: !1,
                        css: {
                            transformPerspective: b.transformPerspective.text * f.resize.ratio
                        }
                    }), b.parallax.enabled && g.TweenMax.set(b.elements.$parallaxWrapper[0], {
                        autoCSS: !1,
                        css: {
                            transformPerspective: b.transformPerspective.parallax * f.resize.ratio
                        }
                    })
                },
                transformProperties: function(a, b, c, d) {
                    if ("object" == typeof c.x) {
                        for (var e = [], g = 0; g < c.x.length; g++) "string" == typeof c.x[g] ? e[g] = this.getXY(a, c.x[g], "Width") : e[g] = c.x[g] * f.resize.ratio;
                        b.cycle.x = e
                    } else "string" == typeof c.x ? b.x = this.getXY(a, c.x, "Width") : "undefined" != typeof c.x && (b.x = c.x * f.resize.ratio);
                    if ("object" == typeof c.y) {
                        for (var h = [], i = 0; i < c.y.length; i++) "string" == typeof c.y[i] ? h[i] = this.getXY(a, c.y[i], "Height") : h[i] = c.y[i] * f.resize.ratio;
                        b.cycle.y = h
                    } else "string" == typeof c.y ? b.y = this.getXY(a, c.y, "Height") : "undefined" != typeof c.y && (b.y = c.y * f.resize.ratio);
                    if (d && (b = d), "object" == typeof c.transformOrigin) {
                        for (var j = [], k = 0; k < c.transformOrigin.length; k++) j[k] = f.functions.convert.transformOrigin(c.transformOrigin[k], a);
                        b.cycle.transformOrigin = j
                    } else "string" == typeof c.transformOrigin && (b.transformOrigin = f.functions.convert.transformOrigin(c.transformOrigin, a))
                },
                styleProperties: function(b, c) {
                    "undefined" != typeof c.width && (a.isNumeric(c.width) ? b.width = parseInt(c.width) * f.resize.ratio : "string" == typeof c.width && c.width.indexOf("%") !== -1 && (b.width = f.slider.width / 100 * parseInt(c.width))), "undefined" != typeof c.height && (a.isNumeric(c.height) ? b.height = parseInt(c.height) * f.resize.ratio : "string" == typeof c.height && c.height.indexOf("%") !== -1 && (b.height = f.slider.height / 100 * parseInt(c.height))), c.borderRadius && (b.borderRadius = f.resize.borderRadius(c.borderRadius))
                },
                clip: function(b, c, d) {
                    c = a.trim(c.replace("rect(", "").replace(")", ""));
                    for (var k, e = b.data(f.defaults.init.dataKey).responsive, g = Math.ceil(e.outerWidth), h = Math.ceil(e.outerHeight), i = c.indexOf(",") === -1 ? c.split(" ") : c.split(","), j = "", l = 0; l < i.length; l++)
                        if (i[l].indexOf("%") !== -1) switch (l) {
                            case 0:
                                j += parseInt(h / 100 * parseInt(i[l]) * 100) / 100 + "px ";
                                break;
                            case 1:
                                j += d ? parseInt(100 * (g - g / 100 * parseInt(i[l]))) / 100 + "px " : parseInt(g / 100 * parseInt(i[l]) * 100) / 100 + "px ";
                                break;
                            case 2:
                                j += d ? parseInt(100 * (h - h / 100 * parseInt(i[l]))) / 100 + "px " : parseInt(h / 100 * parseInt(i[l]) * 100) / 100 + "px ";
                                break;
                            case 3:
                                j += parseInt(g / 100 * parseInt(i[l]) * 100) / 100 + "px"
                        } else switch (k = parseInt(i[l]) * f.resize.ratio, l) {
                            case 0:
                                j += k + "px ";
                                break;
                            case 1:
                                j += d ? g - k + " " : k + "px ";
                                break;
                            case 2:
                                j += d ? h - k + "px " : k + "px ";
                                break;
                            case 3:
                                j += k + "px"
                        }
                        return "rect(" + j + ")"
                },
                getXY: function(a, b, c) {
                    var d = 0,
                        e = a.data(f.defaults.init.dataKey),
                        g = e.original,
                        h = e.responsive,
                        i = e.settings.wrapperData.responsive;
                    if (g && h && i) switch (b) {
                        case "left":
                            d = g.left.indexOf("%") != -1 ? "100%" === g.left ? -h.left - h.outerWidth - i.marginLeft : -parseInt(g.left) / 100 * f.slider.width - h.outerWidth / 2 - i.marginLeft : -h.left - h.outerWidth - i.marginLeft;
                            break;
                        case "right":
                            d = g.left.indexOf("%") != -1 ? "100%" === g.left ? f.slider.width - h.left - i.marginLeft : (1 - parseInt(g.left) / 100) * f.slider.width + h.outerWidth / 2 - i.marginLeft : f.slider.width - h.left - i.marginLeft;
                            break;
                        case "top":
                            d = g.top.indexOf("%") != -1 ? "100%" === g.top ? -h.top - h.outerHeight - i.marginTop : -parseInt(g.top) / 100 * f.slider.height - h.outerHeight / 2 - i.marginTop : -h.top - h.outerHeight - i.marginTop;
                            break;
                        case "bottom":
                            d = g.top.indexOf("%") != -1 ? "100%" === g.top ? f.slider.height - h.top - i.marginTop : (1 - parseInt(g.top) / 100) * f.slider.height + h.outerHeight / 2 - i.marginTop : f.slider.height - h.top - i.marginTop;
                            break;
                        case "width":
                            d = h.outerWidth;
                            break;
                        case "-width":
                            d = -h.outerWidth;
                            break;
                        case "height":
                            d = h.outerHeight;
                            break;
                        case "-height":
                            d = -h.outerHeight;
                            break;
                        default:
                            d = b.indexOf("%") !== -1 ? h["outer" + c] / 100 * parseInt(b) : b.indexOf("sw") !== -1 ? parseInt(b.split("sw")[0]) / 100 * f.slider.width : b.indexOf("sh") !== -1 ? parseInt(b.split("lw")[0]) / 100 * f.slider.height : b.indexOf("lw") !== -1 ? h.outerWidth / 100 * parseInt(b.split("lw")[0]) : b.indexOf("lh") !== -1 ? h.outerHeight / 100 * parseInt(b.split("lj")[0]) : parseInt(b) * f.resize.ratio
                    }
                    return d
                },
                navigation: function() {
                    "always" == f.o.thumbnailNavigation && f.gui.navigation.bottom.thumbnails.resize()
                },
                shadow: function() {
                    f.gui.shadow.show && f.gui.shadow.show(), f.gui.shadow.$element && f.gui.shadow.resize()
                },
                yourLogo: function() {
                    f.yourLogo.$element && f.yourLogo.resize()
                },
                timers: function() {
                    if (f.gui.timers.slidebar.$containerElement.length > 0)
                        for (var a = 0, b = f.gui.timers.slidebar.$containerElement.length; a < b; a++) f.gui.timers.slidebar.containerElementWidth[a] = f.gui.timers.slidebar.$containerElement[a].width(), f.gui.timers.slidebar.elementWidth[a] = f.gui.timers.slidebar.$element[a].width()
                }
            }, f.transitions = {
                firstSlide: !0,
                start: function() {
                    return !!document.body.contains(b) && (f.device.scroll.directionAtSlideTransitionStart = f.device.scroll.direction, "always" == f.o.thumbnailNavigation && (f.gui.navigation.bottom.thumbnails.change(), "ontouchstart" in window || f.gui.navigation.bottom.thumbnails.scroll()), this.layers.out.forced(), void this.slide.init())
                },
                slide: {
                    $wrapper: a(),
                    init: function() {
                        var b, c;
                        if (f.functions.setStates(f.slider, {
                                animatingSlides: !0
                            }), f.transitions.layers.parallax.reset(), f.slider.$layersWrapper.children('.ls-parallax[data-parallax="active"]').each(function() {
                                a(this).find(".ls-layer").data(f.defaults.init.dataKey).settings.slideOut === f.slides.current.index && a(this).attr("data-parallax", "disbaled")
                            }), f.transitions.curSlide = f.slides.current, f.transitions.nextSlide = f.slides.next, f.transitions._slideTransition = new g.TimelineMax({
                                paused: !0,
                                onComplete: function() {
                                    f.transitions.slide.onComplete()
                                }
                            }), f.transitions.firstSlide) {
                            if ("undefined" != typeof f.transitions.nextSlide.data.$background) {
                                var d = f.transitions.nextSlide.data.$background.data(f.defaults.init.dataKey),
                                    e = d.kenBurns.zoom ? d.kenBurns.from.scale : 1,
                                    h = d.kenBurns.zoom ? d.kenBurns.from.rotation : 0,
                                    i = f.transitions.nextSlide.filter.from || "none";
                                f.transitions._slideTransition.set(f.transitions.nextSlide.data.$background[0], {
                                    "-webkit-filter": i,
                                    filter: i
                                }, 0), f.transitions._slideTransition.fromTo(f.transitions.nextSlide.data.$background.closest(".ls-bg-wrap")[0], f.o.sliderFadeInDuration, {
                                    autoCSS: !1,
                                    css: {
                                        scale: e,
                                        rotation: h,
                                        opacity: 0,
                                        display: "block"
                                    }
                                }, {
                                    autoCSS: !1,
                                    css: {
                                        opacity: 1
                                    }
                                }, 0)
                            }
                            this.start(!0)
                        } else "undefined" == typeof layerSliderTransitions && "undefined" == typeof layerSliderCustomTransitions ? (this.start(!0), f.debugMode && f.debug.add("warn", "slideTransition.noSlideTransition", f.transitions.nextSlide.index)) : "undefined" == typeof f.transitions.curSlide.data.$background && "undefined" == typeof f.transitions.nextSlide.data.$background && "transparent" == f.transitions.curSlide.data.backgroundColor && "transparent" == f.transitions.nextSlide.data.backgroundColor ? this.start(!0) : ("x" === f.o.clipSlideTransition ? f.device.$overflowWrapper.addClass("ls-overflowx-hidden") : "y" === f.o.clipSlideTransition ? f.device.$overflowWrapper.addClass("ls-overflowy-hidden") : f.o.clipSlideTransition === !0 && f.device.$overflowWrapper.addClass("ls-overflow-hidden"), "undefined" != typeof f.transitions.curSlide.data.$background && (b = f.transitions.curSlide.data.$background.closest(".ls-bg-wrap")[0]._gsTransform, c = f.transitions.curSlide.data.$background.data(f.defaults.init.dataKey), c.responsive.filter = f.transitions.curSlide.data.$background[0].style.filter, c.responsive.kbRotation = "undefined" != typeof b ? " rotate(" + b.rotation + "deg)" : " rotate(0deg)", c.responsive.kbScale = "undefined" != typeof b ? " scale(" + b.scaleX + ")" : " scale(1)"), f.transitions.slide.$wrapper = a("<div>").addClass("ls-slide-transition-wrapper").css({
                            width: f.slider.width,
                            height: f.slider.height
                        }), this.select.slideTransitionType())
                    },
                    select: {
                        slideTransitionType: function() {
                            f.transitions.slide.normal.select.transitionType()
                        }
                    },
                    start: function(a) {
                        var b, d = !(!f.slides.current.index || !f.slides.current.data.$backgroundVideo.length),
                            e = !(!f.slides.next.index || !f.slides.next.data.$backgroundVideo.length);
                        if (!f.slideshow.firstStart && f.api.hasEvent("slideChangeDidStart") && c.triggerHandler("slideChangeDidStart", f.api.eventData()), !a && ("undefined" != typeof f.transitions.nextSlide.data.transitionDuration && f.transitions._slideTransition.duration(f.transitions.nextSlide.data.transitionDuration), f.debugMode && f.debug.options.transitionDuration && f.transitions._slideTransition.duration(f.debug.options.transitionDuration), f.transitions.layers.timeline.timeScaleModifier > .25)) {
                            var h = f.transitions._slideTransition.duration() / (.75 + f.transitions.layers.timeline.timeScaleModifier);
                            h = h < .5 ? .5 : h, f.transitions._slideTransition.duration(h)
                        }
                        var l, i = f.transitions._slideTransition.duration() / f.transitions._slideTransition.timeScale(),
                            j = i,
                            k = f.transitions.nextSlide.data.timeShift;
                        k > 0 ? k = 0 : k < 0 && Math.abs(k) > i && (k = -i), f.transitions.nextSlide.data.calculatedTimeShift = k, l = f.transitions.firstSlide ? f.o.sliderFadeInDuration + .01 : (j + k) * f.transitions._slideTransition.timeScale(), (d || e) && f.transitions.media.changeBackgroundVideo(f.transitions.firstSlide, !(!d || !e)), f.transitions._slideTransition.call(function() {
                            !f.slideshow.firstStart && f.api.hasEvent("slideChangeWillComplete") && c.triggerHandler("slideChangeWillComplete", f.api.eventData()), f.slideshow.should.change || f.transitions.layers.timeline.prepare(), f.media.stop(), f.slides.set.slideIndexes(), f.slideshow.start(), !f.transitions.firstSlide && f.slides.prev.index && f.slides.prev.data.$backgroundVideo.length && !f.slides.prev.data.$backgroundVideo.data(f.defaults.init.dataKey).mediaProperties.willBePaused && (f.slides.prev.data.$backgroundVideo.trigger("stopBackgroundVideo"), f.slides.prev.data.$backgroundVideo.data(f.defaults.init.dataKey).elements.$bgWrapper.css({
                                display: "none"
                            })), f.slideshow.should.change || f.slides.next.data.$backgroundVideo.length && !f.slides.next.data.$backgroundVideo.data(f.defaults.init.dataKey).mediaProperties.isPreloaded && (f.slides.next.data.$backgroundVideo.trigger("preloadBackgroundVideo"), f.slides.next.data.$backgroundVideo.data(f.defaults.init.dataKey).mediaProperties.isPreloaded = !0), f.transitions.firstSlide = !1
                        }, [], this, l), f.transitions._slideTransition.play(), "undefined" != typeof f.transitions.curSlide.data && "undefined" != typeof f.transitions.curSlide.data.$background && (b = f.transitions.curSlide.data.$background.data(f.defaults.init.dataKey), f.timeouts.applyBG = setTimeout(function() {
                            delete f.timeouts.applyBG, f.transitions.curSlide.data.$background.closest(".ls-bg-wrap").hide(), b.kenBurns.zoom && g.TweenMax.set(f.transitions.curSlide.data.$background[0], {
                                autoCSS: !1,
                                css: b.kenBurns.from
                            })
                        }, 5))
                    },
                    onComplete: function() {
                        var a;
                        "undefined" != typeof f.transitions.nextSlide.data.$background && f.transitions.nextSlide.data.$background.closest(".ls-bg-wrap").show(), "transparent" !== f.transitions.nextSlide.data.backgroundColor ? f.slider.$innerWrapper.css("background-color", f.transitions.nextSlide.data.backgroundColor) : f.slider.$innerWrapper.css("background-color", f.o.globalBGColor), f.o.leaveOverflow || f.device.$overflowWrapper.removeClass("ls-overflowx-hidden ls-overflowy-hidden ls-overflow-hidden"), this.$wrapper && (this.$wrapper.html("").remove(), this.$wrapper = !1), f.gui.navigation.bottom.bullets.set.active(), f.o.cycles > 0 && (f.slideshow.hasOwnProperty("cycleSlideIndex") ? f.slideshow.cycles.check(f.transitions.nextSlide.index) && (f.navigation.stop(), f.functions.setStates(f.slideshow, {
                            pausedByLastCycle: !0
                        }), f.o.forceCycles && (f.slideshow.curCycle = 1)) : f.slideshow.cycles.set()), f.functions.setStates(f.slider, {
                            animatingSlides: !1,
                            changingSlides: !1
                        }), !f.slideshow.firstStart && f.api.hasEvent("slideChangeDidComplete") && c.triggerHandler("slideChangeDidComplete", f.api.eventData()), f.slideshow.firstStart = !1, f.slideshow.should.change !== !1 && f.navigation.forceDirection ? ("undefined" != typeof f.transitions.curSlide.data && "undefined" != typeof f.transitions.curSlide.data.$background && (a = f.transitions.curSlide.data.$background.data(f.defaults.init.dataKey), f.transitions.curSlide.data.$background.closest(".ls-bg-wrap").hide(), a.kenBurns.zoom && g.TweenMax.set(f.transitions.curSlide.data.$background[0], {
                            autoCSS: !1,
                            css: a.kenBurns.from
                        })), f.slideshow.changeTo(f.slideshow.get.slideInSequence(f.navigation.forceDirection), !0)) : f.preload.imagesOfSlide(f.slides.next.index)
                    },
                    normal: {
                        select: {
                            transitionType: function() {
                                if (f.o.slideTransition) return void f.transitions.slide.normal.setTransition(f.o.slideTransition.type, f.o.slideTransition.obj);
                                var a, b, c = !!f.transitions.nextSlide.data.transition2d && f.transitions.nextSlide.data.transition2d.toString().split(",");
                                f.device.touchPrev && f.o.slideOnSwipe ? (f.device.touchPrev = !1, this.transition("2d", "1")) : f.device.touchNext && f.o.slideOnSwipe ? (f.device.touchNext = !1, this.transition("2d", "1")) : f.slides.next.data.$background || c && (!c || c.indexOf("1") != -1 || c.indexOf("2") != -1 || c.indexOf("3") != -1 || c.indexOf("4") != -1) ? f.browser.supports3D() && (f.transitions.nextSlide.data.transition3d || f.transitions.nextSlide.data.customtransition3d) ? f.transitions.nextSlide.data.transition3d && f.transitions.nextSlide.data.customtransition3d ? (a = Math.floor(2 * Math.random()), b = [
                                    ["3d", f.transitions.nextSlide.data.transition3d],
                                    ["custom3d", f.transitions.nextSlide.data.customtransition3d]
                                ], this.transition(b[a][0], b[a][1])) : f.transitions.nextSlide.data.transition3d ? this.transition("3d", f.transitions.nextSlide.data.transition3d) : this.transition("custom3d", f.transitions.nextSlide.data.customtransition3d) : f.transitions.nextSlide.data.transition2d && f.transitions.nextSlide.data.customtransition2d ? (a = Math.floor(2 * Math.random()), b = [
                                    ["2d", f.transitions.nextSlide.data.transition2d],
                                    ["custom2d", f.transitions.nextSlide.data.customtransition2d]
                                ], this.transition(b[a][0], b[a][1])) : f.transitions.nextSlide.data.transition2d ? this.transition("2d", f.transitions.nextSlide.data.transition2d) : f.transitions.nextSlide.data.customtransition2d ? this.transition("custom2d", f.transitions.nextSlide.data.customtransition2d) : this.transition("2d", "1") : this.transition("2d", "5")
                            },
                            transition: function(a, b) {
                                f.debugMode && f.debug.add("group", "slideTransition.info"), b += "";
                                var e, g, c = a.indexOf("custom") == -1 ? f.t : f.ct,
                                    d = "3d";
                                if (a.indexOf("2d") != -1 && (d = "2d"), b.indexOf("last") != -1) g = c["t" + d].length - 1, e = "last";
                                else if (b.indexOf("all") != -1) g = Math.floor(Math.random() * f.functions.countProp(c["t" + d])), e = "random from all";
                                else {
                                    var h = b.split(","),
                                        i = h.length;
                                    g = parseInt(h[Math.floor(Math.random() * i)]) - 1, e = "random from specified"
                                }
                                "undefined" == typeof c["t" + d][g] && (f.debugMode && f.debug.add("warn", "slideTransition.customTransition", [d.toUpperCase() + (a.indexOf("custom") === -1 ? "" : " (CUSTOM)"), g + 1]), c = f.t, a = d = "2d", g = 0), f.debugMode && f.debug.add("log", "slideTransition.info", [d.toUpperCase() + (a.indexOf("custom") === -1 ? "" : " (CUSTOM)"), g + 1, c["t" + d][g].name]), f.transitions.slide.normal.setTransition(d, c["t" + d][g])
                            }
                        },
                        setTransition: function(b, c) {
                            var i, j, k, l, d = a.extend(!0, {
                                    cols: 1,
                                    rows: 1
                                }, c),
                                e = typeof d.cols,
                                h = typeof d.rows,
                                m = [],
                                n = f.navigation.direction,
                                o = 0,
                                p = 0,
                                q = !!f.transitions.curSlide.data.$background && f.functions.getURL(f.transitions.curSlide.data.$background),
                                r = !!f.transitions.nextSlide.data.$background && f.functions.getURL(f.transitions.nextSlide.data.$background),
                                s = f.o.playByScroll && "up" === f.device.scroll.direction ? "to" : "from";
                            switch (e) {
                                case "number":
                                    e = d.cols;
                                    break;
                                case "string":
                                    e = Math.floor(Math.random() * (parseInt(d.cols.split(",")[1]) - parseInt(d.cols.split(",")[0]) + 1)) + parseInt(d.cols.split(",")[0]);
                                    break;
                                default:
                                    e = Math.floor(Math.random() * (d.cols[1] - d.cols[0] + 1)) + d.cols[0]
                            }
                            switch (h) {
                                case "number":
                                    h = d.rows;
                                    break;
                                case "string":
                                    h = Math.floor(Math.random() * (parseInt(d.rows.split(",")[1]) - parseInt(d.rows.split(",")[0]) + 1)) + parseInt(d.rows.split(",")[0]);
                                    break;
                                default:
                                    h = Math.floor(Math.random() * (d.rows[1] - d.rows[0] + 1)) + d.rows[0]
                            }
                            if (f.device.isMobile && f.o.optimizeForMobile ? (e >= 15 ? e = 7 : e >= 5 ? e = 4 : e >= 4 ? e = 3 : e > 2 && (e = 2), h >= 15 ? h = 7 : h >= 5 ? h = 4 : h >= 4 ? h = 3 : h > 2 && (h = 2), h > 2 && e > 2 && (h = 2, e > 4 && (e = 4))) : (e = e > 35 ? 35 : e, h = h > 35 ? 35 : h), f.debugMode && !f.o.slideTransition && (f.debug.add("log", "slideTransition.properties", [
                                    [e, h], e * h
                                ]), f.debug.groupEnd()), i = Math.floor(f.slider.width / e), j = Math.floor(f.slider.height / h), k = f.slider.width - i * e, l = f.slider.height - j * h, "prev" == n) {
                                var t = {
                                    random: "random",
                                    forward: "reverse",
                                    reverse: "forward",
                                    "col-forward": "col-reverse",
                                    "col-reverse": "col-forward"
                                };
                                d.tile && d.tile.sequence && (d.tile.sequence = t[d.tile.sequence]), a.each(["animation", "before", "after"], function(a, b) {
                                    if (d[b] && d[b].transition) {
                                        var c = d[b].transition;
                                        c.rotateX && Math.abs(c.rotateX) > 44 && (c.rotateX *= -1), c.rotateY && Math.abs(c.rotateY) > 44 && (c.rotateY *= -1), c.rotate && (c.rotate *= -1)
                                    }
                                })
                            }
                            for (var u = 0; u < e * h; u++) m.push(u);
                            switch (d.tile.sequence) {
                                case "reverse":
                                    m.reverse();
                                    break;
                                case "col-forward":
                                    m = f.functions.sortArray(h, e, "forward");
                                    break;
                                case "col-reverse":
                                    m = f.functions.sortArray(h, e, "reverse");
                                    break;
                                case "random":
                                    m = f.functions.shuffleArray(m)
                            }
                            if ("transparent" === f.transitions.curSlide.data.backgroundColor && (f.transitions.curSlide.data.backgroundColor = f.o.globalBGColor), "transparent" === f.transitions.nextSlide.data.backgroundColor && (f.transitions.nextSlide.data.backgroundColor = f.o.globalBGColor), "2d" == b) {
                                var v = d.name.toLowerCase().indexOf("carousel") != -1,
                                    w = d.name.toLowerCase().indexOf("crossfad") != -1;
                                this.$curTiles = a("<div>").addClass("ls-curtiles").appendTo(f.transitions.slide.$wrapper), this.$nextTiles = a("<div>").addClass("ls-nexttiles").appendTo(f.transitions.slide.$wrapper)
                            }
                            for (var x = 0; x < e * h; x++) {
                                var B, C, D, E, H, I, J, y = (x + 1) % e === 0 ? k : 0,
                                    z = x > (h - 1) * e - 1 ? l : 0,
                                    A = a("<div>").addClass("ls-slide-transition-tile").css({
                                        width: i + y,
                                        height: j + z
                                    }).data("style", {
                                        width: i + y,
                                        height: j + z
                                    }).appendTo(f.transitions.slide.$wrapper);
                                m[x] == e * h - 1 && function() {
                                    f.transitions.slide.onComplete()
                                };
                                if (o = x % e === 0 ? o + 1 : o, p = x % e === 0 ? 1 : p + 1, "3d" == b) {
                                    A.addClass("ls-3d-container");
                                    var N, O, P, Q, U, V, Y, L = i + y,
                                        M = j + z,
                                        Z = new g.TimelineMax;
                                    Y = Math.abs(Math.abs(p - e / 2 - .5) - e / 2 - .5) * Math.abs(Math.abs(o - h / 2 - .5) - h / 2 - .5), A.css({
                                        zIndex: Y
                                    }), N = "horizontal" == d.animation.direction ? Math.abs(d.animation.transition.rotateY) > 90 && "large" != d.tile.depth ? Math.floor(L / 7) + y : L : Math.abs(d.animation.transition.rotateX) > 90 && "large" != d.tile.depth ? Math.floor(M / 7) + z : M, O = L / 2, P = M / 2, Q = N / 2, this.createCuboids("ls-3d-box", A, 0, 0, 0, 0, -Q, 0, 0, O + "px " + P + "px 0px"), this.createCuboids("ls-3d-front", A.find(".ls-3d-box"), L, M, 0, 0, Q, 0, 0), "vertical" == d.animation.direction && Math.abs(d.animation.transition.rotateX) > 90 ? this.createCuboids("ls-3d-back", A.find(".ls-3d-box"), L, M, 0, 0, -Q, 180, 0) : this.createCuboids("ls-3d-back", A.find(".ls-3d-box"), L, M, 0, 0, -Q, 0, 180), this.createCuboids("ls-3d-left", A.find(".ls-3d-box"), N, M, -Q, 0, 0, 0, -90), this.createCuboids("ls-3d-right", A.find(".ls-3d-box"), N, M, L - Q, 0, 0, 0, 90), this.createCuboids("ls-3d-top", A.find(".ls-3d-box"), L, N, 0, -Q, 0, 90, 0), this.createCuboids("ls-3d-bottom", A.find(".ls-3d-box"), L, N, 0, M - Q, 0, -90, 0), B = A.find(".ls-3d-front"), C = "horizontal" == d.animation.direction ? Math.abs(d.animation.transition.rotateY) > 90 ? A.find(".ls-3d-back") : d.animation.transition.rotateY > 0 ? A.find(".ls-3d-left") : A.find(".ls-3d-right") : Math.abs(d.animation.transition.rotateX) > 90 ? A.find(".ls-3d-back") : d.animation.transition.rotateX > 0 ? A.find(".ls-3d-bottom") : A.find(".ls-3d-top"), U = m[x] * d.tile.delay, V = f.transitions.slide.$wrapper.find(".ls-3d-container:eq( " + x + " ) .ls-3d-box"), d.before && d.before.transition ? (d.before.transition.delay = d.before.transition.delay ? (d.before.transition.delay + U) / 1e3 : U / 1e3, Z.to(V[0], d.before.duration / 1e3, f.functions.convert.transition(d.before.transition, d.before.easing))) : d.animation.transition.delay = d.animation.transition.delay ? (d.animation.transition.delay + U) / 1e3 : U / 1e3, Z.to(V[0], d.animation.duration / 1e3, f.functions.convert.transition(d.animation.transition, d.animation.easing)), d.after && (d.after.transition || (d.after.transition = {}), Z.to(V[0], d.after.duration / 1e3, f.functions.convert.transition(d.after.transition, d.after.easing, "after"))), f.transitions._slideTransition.add(Z, 0)
                                } else {
                                    var ea, fa, ga, ha, ia, ja, ka, la, $ = "auto",
                                        _ = "auto",
                                        aa = "auto",
                                        ba = "auto",
                                        ca = 1,
                                        da = 1,
                                        ma = {};
                                    switch ("random" == d.transition.direction ? (ea = ["top", "bottom", "right", "left"], fa = ea[Math.floor(Math.random() * ea.length)]) : fa = d.transition.direction, d.name.toLowerCase().indexOf("mirror") != -1 && x % 2 === 0 && (n = "prev" == n ? "next" : "prev"), "prev" == n && (fa = {
                                        top: "bottom",
                                        bottom: "top",
                                        left: "right",
                                        right: "left",
                                        topleft: "bottomright",
                                        topright: "bottomleft",
                                        bottomleft: "topright",
                                        bottomright: "topleft"
                                    }[fa]), fa) {
                                        case "top":
                                            $ = aa = -A.data("style").height, _ = ba = 0;
                                            break;
                                        case "bottom":
                                            $ = aa = A.data("style").height, _ = ba = 0;
                                            break;
                                        case "left":
                                            $ = aa = 0, _ = ba = -A.data("style").width;
                                            break;
                                        case "right":
                                            $ = aa = 0, _ = ba = A.data("style").width;
                                            break;
                                        case "topleft":
                                            $ = A.data("style").height, aa = 0, _ = A.data("style").width, ba = 0;
                                            break;
                                        case "topright":
                                            $ = A.data("style").height, aa = 0, _ = -A.data("style").width, ba = 0;
                                            break;
                                        case "bottomleft":
                                            $ = -A.data("style").height, aa = 0, _ = A.data("style").width, ba = 0;
                                            break;
                                        case "bottomright":
                                            $ = -A.data("style").height, aa = 0, _ = -A.data("style").width, ba = 0
                                    }
                                    switch (this.scale2D = d.transition.scale ? d.transition.scale : 1, 1 == v && 1 != this.scale2D && ($ /= 2, aa /= 2, _ /= 2, ba /= 2), d.transition.type) {
                                        case "fade":
                                            $ = aa = _ = ba = 0, ca = 0, da = 1;
                                            break;
                                        case "mixed":
                                            ca = 0, da = 1, 1 == this.scale2D && (aa = ba = 0)
                                    }
                                    if ((d.transition.rotate || d.transition.rotateX || d.transition.rotateY || 1 != this.scale2D) && "slide" != d.transition.type ? A.css({
                                            overflow: "visible"
                                        }) : A.css({
                                            overflow: "hidden"
                                        }), 1 == v ? this.$curTiles.css({
                                            overflow: "visible"
                                        }) : this.$curTiles.css({
                                            overflow: "hidden"
                                        }), w === !0 || "slide" == d.transition.type || v === !0 ? (ga = A.appendTo(this.$curTiles), ha = A.clone().appendTo(this.$nextTiles), B = a("<div>").addClass("ls-curtile").appendTo(ga)) : ha = A.appendTo(this.$nextTiles), C = a("<div>").addClass("ls-nexttile").appendTo(ha), ia = m[x] * d.tile.delay / 1e3, ja = d.transition.rotate ? d.transition.rotate : 0, ka = d.transition.rotateX ? d.transition.rotateX : 0, la = d.transition.rotateY ? d.transition.rotateY : 0, "prev" == n && (ja = -ja, ka = -ka, la = -la), f.transitions._slideTransition.fromTo(C[0], d.transition.duration / 1e3, {
                                            immediateRender: !1,
                                            autoCSS: !1,
                                            css: {
                                                x: -_,
                                                y: -$,
                                                display: "block",
                                                opacity: ca,
                                                rotation: ja,
                                                rotationX: ka,
                                                rotationY: la,
                                                scale: this.scale2D
                                            }
                                        }, {
                                            autoCSS: !1,
                                            css: {
                                                x: 0,
                                                y: 0,
                                                opacity: da,
                                                rotation: 0,
                                                rotationX: 0,
                                                rotationY: 0,
                                                scale: 1
                                            },
                                            ease: f.functions.convert.easing(d.transition.easing)
                                        }, ia), 1 == w && ("undefined" == typeof f.transitions.nextSlide.data.$background || "undefined" != typeof f.transitions.nextSlide.data.$background && (f.transitions.nextSlide.data.$background.attr("src").toLowerCase().indexOf("png") != -1 || f.transitions.nextSlide.data.$background.width() < f.slider.width || f.transitions.nextSlide.data.$background.height() < f.slider.height)) && (ma.opacity = 0), ("slide" == d.transition.type || 1 == v) && d.name.toLowerCase().indexOf("mirror") == -1) {
                                        var na = 0;
                                        0 !== ja && (na = -ja), ma.x = ba, ma.y = aa, ma.rotation = na, ma.scale = this.scale2D, ma.opacity = ca
                                    }
                                    "undefined" != typeof B && f.transitions._slideTransition.to(B[0], d.transition.duration / 1e3, {
                                        autoCSS: !1,
                                        css: ma,
                                        ease: f.functions.convert.easing(d.transition.easing)
                                    }, ia)
                                }
                                D = x % e * i, E = Math.floor(x / e) * j, "undefined" != typeof f.transitions.curSlide.data.$background && (H = f.transitions.curSlide.data.$background.data(f.defaults.init.dataKey), "3d" === b || "2d" === b && (w === !0 || "slide" === d.transition.type || v === !0) ? B.append(a("<img>").attr("src", q).css({
                                    width: H.responsive.width,
                                    height: H.responsive.height,
                                    "-webkit-filter": H.responsive.filter,
                                    filter: H.responsive.filter,
                                    "-ms-transform": "translateX(" + (H.responsive.x - D) + "px) translateY(" + (H.responsive.y - E) + "px)" + H.responsive.kbRotation + H.responsive.kbScale,
                                    "-webkit-transform": "translateX(" + (H.responsive.x - D) + "px) translateY(" + (H.responsive.y - E) + "px)" + H.responsive.kbRotation + H.responsive.kbScale,
                                    transform: "translateX(" + (H.responsive.x - D) + "px) translateY(" + (H.responsive.y - E) + "px)" + H.responsive.kbRotation + H.responsive.kbScale
                                })) : 0 === this.$curTiles.children().length && this.$curTiles.css("background-color", f.transitions.curSlide.data.backgroundColor).append(a("<img>").attr("src", q).css({
                                    width: H.responsive.width,
                                    height: H.responsive.height,
                                    "-webkit-filter": H.responsive.filter,
                                    filter: H.responsive.filter,
                                    "-ms-transform": "translateX(" + H.responsive.x + "px) translateY(" + H.responsive.y + "px)" + H.responsive.kbRotation + H.responsive.kbScale,
                                    "-webkit-transform": "translateX(" + H.responsive.x + "px) translateY(" + H.responsive.y + "px)" + H.responsive.kbRotation + H.responsive.kbScale,
                                    transform: "translateX(" + H.responsive.x + "px) translateY(" + H.responsive.y + "px)" + H.responsive.kbRotation + H.responsive.kbScale
                                }))), "transparent" === f.transitions.curSlide.data.backgroundColor || f.transitions.curSlide.data.$backgroundVideo.length || ("3d" === b || "2d" === b && (w === !0 || "slide" === d.transition.type || v === !0) ? B.css("background-color", f.transitions.curSlide.data.backgroundColor) : 0 === this.$curTiles.children().length && this.$curTiles.css("background-color", f.transitions.curSlide.data.backgroundColor)), "undefined" != typeof f.transitions.nextSlide.data.$background && (I = f.transitions.nextSlide.data.$background.data(f.defaults.init.dataKey), J = I.kenBurns[s], C.append(a("<img>").attr("src", r).css({
                                    width: I.responsive.width,
                                    height: I.responsive.height,
                                    "-webkit-filter": f.transitions.nextSlide.filter.from || "none",
                                    filter: f.transitions.nextSlide.filter.from || "none",
                                    "-ms-transform": "translateX(" + (I.responsive.x - D) + "px) translateY(" + (I.responsive.y - E) + "px) rotate(" + J.rotation + "deg) scale(" + J.scale + ")",
                                    "-webkit-transform": "translateX(" + (I.responsive.x - D) + "px) translateY(" + (I.responsive.y - E) + "px) rotate(" + J.rotation + "deg) scale(" + J.scale + ")",
                                    transform: "translateX(" + (I.responsive.x - D) + "px) translateY(" + (I.responsive.y - E) + "px) rotate(" + J.rotation + "deg) scale(" + J.scale + ")"
                                }))), "transparent" === f.transitions.nextSlide.data.backgroundColor || f.transitions.nextSlide.data.$backgroundVideo.length || C.css("background-color", f.transitions.nextSlide.data.backgroundColor)
                            }
                            f.transitions.slide.$wrapper.prependTo(f.slider.$layersWrapper), f.transitions.slide.start()
                        },
                        createCuboids: function(b, c, d, e, f, g, h, i, j, k) {
                            var l = "translate3d( " + f + "px, " + g + "px, " + h + "px)";
                            0 !== i && (l += "rotateX( " + i + "deg)"), 0 !== j && (l += "rotateY( " + j + "deg)");
                            var m = {
                                width: d,
                                height: e,
                                transform: l,
                                "-ms-transform": l,
                                "-webkit-transform": l
                            };
                            k && (m["transform-origin"] = k, m["-ms-transform-origin"] = k, m["-webkit-transform-origin"] = k), a("<div>").addClass(b).css(m).appendTo(c)
                        }
                    }
                },
                layers: { in : {
                        onStart: function(a) {
                            var b = a.data(f.defaults.init.dataKey);
                            b.hover.enabled && f.transitions.layers.hover.enable(a)
                        },
                        onComplete: function(a) {
                            var b = a.data(f.defaults.init.dataKey);
                            b.is.mediaLayer && (f.device.isMobile && (c.hasClass("ls-device-is-phone") && b.elements.$outerWrapper.hasClass("ls-hide-on-phone") || c.hasClass("ls-device-is-tablet") && b.elements.$outerWrapper.hasClass("ls-hide-on-tablet")) || (null === b.mediaSettings.autoplay && f.o.autoPlayVideos || b.mediaSettings.autoplay) && a.find(".ls-vpcontainer").trigger("playVideo"))
                        }
                    }, out: {
                        forced: function() {
                            if (f.transitions._forceLayersOut) {
                                if (f.transitions._slideTimeline) {
                                    var c, d, b = new g.TimelineMax({
                                            paused: !0,
                                            autoRemoveChildren: !0
                                        }),
                                        e = [],
                                        i = 100,
                                        j = f.layers.get("current, in, static, active").add(f.layers.get("current, out, static, active")),
                                        k = f.layers.get("current, out, notstatic, active"),
                                        l = f.layers.get("current, out, active"),
                                        m = a().add(j).add(k),
                                        n = function(a) {
                                            b.add(a, i - a.duration() * a.progress())
                                        };
                                    m.each(function() {
                                        var b = a(this),
                                            g = b.data(f.defaults.init.dataKey);
                                        if (g.loop._timeline && (f.transitions._slideTimeline.remove(g.loop._timeline), g.loop._timeline.play()), g.is.static) {
                                            c = [g.elements.$wrapper[0]], g.elements.$clipWrapper && (c = c.concat(g.elements.$clipWrapper[0])), g.textIn.nodes && (c = c.concat(g.textIn.nodes));
                                            for (var h = 0; h < c.length; h++) e = e.concat(f.transitions._slideTimeline.getTweensOf(c[h], !0));
                                            for (var i = 0; i < e.length; i++) e[i].duration && 0 !== e[i].duration() && (d = e[i], n(d))
                                        }
                                    }), l.each(function() {
                                        var b = a(this),
                                            c = b.data(f.defaults.init.dataKey);
                                        c.should.reset = !0
                                    }), b.play().seek(i), f.transitions._slideTimeline.stop().clear()
                                }
                                f.transitions._forceLayersOut.play()
                            }
                            f.slider.$layersWrapper.find(".ls-link").css({
                                display: "none"
                            })
                        },
                        onStart: function(a) {},
                        onComplete: function(a) {
                            var b = a.data(f.defaults.init.dataKey);
                            (f.slider.state.changingSlides || b.settings.slideOut !== f.slides.current.index) && f.transitions.layers.reset(a, b), b.hover.enabled && f.transitions.layers.hover.disable(a)
                        }
                    }, reset: function(a, b) {
                        b.loop._timeline && (b.loop._timeline.stop().clear(), delete b.loop._timeline, g.TweenMax.set(b.elements.$loopWrapper[0], b.reset.loopWrapperOnSlideChange)), g.TweenMax.set(b.elements.$wrapper[0], b.reset.wrapperOnSlideChange), g.TweenMax.set(a[0], {
                            "-webkit-filter": "none",
                            filter: "none"
                        }), b.should.update && (b.textInNodesFrom.random = {}, b.textOutNodesTo.random = {}, f.layers.update.data(a)), b.should.reset = !1
                    }, timeline: {
                        shouldRestart: !1,
                        create: function(b) {
                            var d, e, h, i, j = b ? "current" : "next";
                            f.transitions.curNext = j, f.transitions.layers.timeline.shouldRestart = !1, f.transitions.layers.timeline.resetStates(), f.transitions._slideTimeline && (f.transitions._slideTimeline.pause().progress(0).kill().clear(!0), f.transitions._slideTimeline = null), f.transitions._slideTimeline = new g.TimelineMax({
                                paused: !0,
                                onStart: function() {
                                    f.api.hasEvent("slideTimelineDidStart") && c.triggerHandler("slideTimelineDidStart", f.api.eventData())
                                },
                                onReverseComplete: function() {
                                    f.api.hasEvent("slideTimelineDidReverseComplete") && c.triggerHandler("slideTimelineDidReverseComplete", f.api.eventData()), f.transitions.layers.timeline.shouldReplay && (f.transitions.layers.timeline.shouldRestart = !1, f.transitions._slideTimeline.play())
                                },
                                onUpdate: function(a) {
                                    f.api.hasEvent("slideTimelineDidUpdate") && c.triggerHandler("slideTimelineDidUpdate", a)
                                },
                                onUpdateParams: ["{self}"]
                            }), this.totalDuration = 0, this.progress = 1, f.transitions._forceLayersOut = new g.TimelineMax({
                                paused: !0,
                                autoRemoveChildren: !0
                            }), d = f.layers.get(j + ", in, notactive"), e = f.layers.get(j + ", out, notstatic").add(f.layers.get(j + ", out, active, static")), h = f.layers.get(j + ", in, bgonly, notactive"), i = a().add(d).add(e).add(h), this.addLayers(d, "in", f.transitions._slideTimeline, f.transitions._forceLayersOut), this.addLayers(e, "out", f.transitions._slideTimeline, f.transitions._forceLayersOut), f.slides[j].data.duration !== -1 && f.slides[j].data.duration < this.totalDuration ? (this.progress = f.slides[j].data.duration / this.totalDuration, f.debugMode && f.debug.add("warn", "slideTimeline.duration", [f.slides[j].data.duration, this.totalDuration])) : f.transitions._slideTimeline.duration() > this.totalDuration && (this.progress = this.totalDuration / f.transitions._slideTimeline.duration()), f.slides[j].data.duration === -1 ? (f.slides[j].data.duration = this.totalDuration, f.slides[f.slides[j].index].data.duration = this.totalDuration) : this.totalDuration = f.slides[j].data.duration, this.addLayers(h, "in", f.transitions._slideTimeline, f.transitions._forceLayersOut), f.transitions.layers.timeline.shouldRestart === !0 && f.debugMode && f.debug.add("warn", "slideTimeline.restart", f.o.allowRestartOnResize ? "enabled" : "disabled");
                            for (var k = 0; k < i.length; k++) a(i[k]).data(f.defaults.init.dataKey).parallax.enabled && a(i[k]).data(f.defaults.init.dataKey).elements.$parallaxWrapper.attr("data-parallax", "active");
                            f.transitions.layers.parallax.trigger(), f.api.hasEvent("slideTimelineDidCreate") && c.triggerHandler("slideTimelineDidCreate", {
                                slideTimeline: f.transitions._slideTimeline,
                                layersOnSlideTimeline: i,
                                slideTimelineDuration: this.totalDuration
                            }), f.transitions.timers.create(), f.transitions.timers.bar._transition && f.transitions._slideTimeline.add(f.transitions.timers.bar._transition.play(), 0), f.transitions.timers.circle._transition && f.transitions._slideTimeline.add(f.transitions.timers.circle._transition.play(), 0), f.transitions.timers.slidebar._transition && f.transitions._slideTimeline.add(f.transitions.timers.slidebar._transition.play(), 0), f.transitions._slideTimeline.call(function() {
                                if (!f.transitions._slideTimeline.reversed()) {
                                    if (f.api.hasEvent("slideTimelineDidComplete") && !1 === c.triggerHandler("slideTimelineDidComplete", f.api.eventData())) return;
                                    f.functions.setStates(f.transitions.layers.timeline, {
                                        finished: !0
                                    }), !f.slideshow.isPaused() && f.slideshow.state.running ? f.slideshow.changeTo(f.slides.next.index) : f.slideshow.state.pausedByLastCycle && f.transitions.timers.reverse()
                                }
                            }, [], this, f.slides[j].data.duration), f.slides.next.data.$link && f.slides.next.data.$link.css({
                                display: "block"
                            }), (f.o.startInViewport && "inside" === f.slider.positionToViewport || !f.o.startInViewport) && (f.o.pauseLayers && f.slideshow.isPaused() && f.transitions._slideTimeline.timeScale(0), f.transitions.layers.timeline.play(), f.o.playByScroll && "up" === f.device.scroll.directionAtSlideTransitionStart && f.transitions._slideTimeline.progress(1))
                        },
                        prepare: function() {
                            f.slides.next.data.overflow && "hidden" !== f.slides.next.data.overflow ? (f.slider.$layersWrapper.addClass("ls-visible"), f.slider.$slideBGWrapper.addClass("ls-visible")) : (f.slider.$layersWrapper.removeClass("ls-visible"), f.slider.$slideBGWrapper.removeClass("ls-visible")), this.create()
                        },
                        getTiming: function(b, c, d, e) {
                            if ("number" == typeof c) return c;
                            c = c.toLowerCase();
                            var h, i, j, k, l, g = f.defaults.layer.timelineHierarchy,
                                m = 0;
                            if (c.indexOf("*") !== -1 && (l = "*"), c.indexOf("/") !== -1 && (l = "/"), c.indexOf("+") !== -1 && (l = "+"), c.indexOf("-") !== -1 && (l = "-"), l)
                                if (k = c.split(l), h = a.trim(k[0]), j = parseInt(a.trim(k[1])), g[h] && g[d][1].indexOf(g[h][0]) !== -1)
                                    if (i = "number" == typeof b.timeline[h] ? b.timeline[h] : b.timeline[h](b), e) m = j / 1e3;
                                    else switch (l) {
                                        case "*":
                                            m = i * j;
                                            break;
                                        case "/":
                                            m = i / j;
                                            break;
                                        case "+":
                                            m = i + j / 1e3;
                                            break;
                                        case "-":
                                            m = i - j / 1e3
                                    } else f.debugMode && (g[h] || f.debug.add("warn", "layerTransition.timing1", h), g[d][1].indexOf(g[h][0]) === -1 && f.debug.add("warn", "layerTransition.timing3", [h, g[h], d, g[d]])), ("+" === l || e) && (m = j / 1e3);
                            else h = a.trim(c), g[h] && g[d][1].indexOf(g[h][0]) !== -1 ? m = e ? 0 : "number" == typeof b.timeline[h] ? b.timeline[h] : b.timeline[h](b) : f.debugMode && (g[h] ? g[d][1].indexOf(g[h][0]) === -1 && f.debug.add("warn", "layerTransition.timing3", [h, g[h], d, g[d]]) : f.debug.add("warn", "layerTransition.timing1", h));
                            return (m !== m || m < 0) && (f.debugMode && f.debug.add("warn", "layerTransition.timing2", [d, h, m]), m = 0), m
                        },
                        addLayers: function(b, c, d, e) {
                            for (var h = 0, i = b.length; h < i; h++) {
                                var o, j = a(b[h]),
                                    k = j.data(f.defaults.init.dataKey),
                                    l = k.elements.$wrapper,
                                    m = k.elements.$clipWrapper,
                                    n = k.elements.$loopWrapper;
                                if (k.should.reset && f.transitions.layers.reset(j, k), j.hasClass("ls-bg")) k.kenBurns.zoom && d.fromTo(j.closest(".ls-bg-wrap"), f.transitions.nextSlide.data.duration + f.transitions.nextSlide.data.calculatedTimeShift, {
                                    autoCSS: !1,
                                    css: k.kenBurns.from
                                }, {
                                    autoCSS: !1,
                                    css: k.kenBurns.to,
                                    ease: g.Quad.easeInOut
                                }, -f.transitions.nextSlide.data.calculatedTimeShift), a.isEmptyObject(k.filter.values.bgFrom) && a.isEmptyObject(k.filter.values.bgTo) || (k.filter.transitions.bg || (k.filter.transitions.bg = f.transitions.layers.filters.createTransition(k, "bg", k.filter.values.bgFrom, k.filter.values.bgTo)), d.to([{
                                    p: 0
                                }, j[0]], f.transitions.nextSlide.data.duration, {
                                    p: 1,
                                    autoCSS: !1,
                                    ease: g.Sine.easeInOut,
                                    onUpdate: f.transitions.layers.filters.animate,
                                    onUpdateParams: ["{self}", k.filter.transitions.bg]
                                }, 0));
                                else switch (c) {
                                    case "in":
                                        if (k.in.enabled && (k.settings.timelineIsCalculated || ("number" != typeof k.in.startAt && (k.in.startAt = 0), k.timeline.transitioninstart = k.in.startAt, k.timeline.transitioninend = k.timeline.transitioninstart + k.in.duration), f.resize.transformProperties(j, k.inLayerFromCSS, k.inLayerShouldBeConverted), f.resize.styleProperties(k.inLayerStyleFromCSS, k.inLayerStyleShouldBeConvertedFrom), f.resize.styleProperties(k.inLayerStyleToCSS, k.inLayerStyleShouldBeConvertedTo), k.inLayerFromCSS.transformPerspective = k.transformPerspective.layer * f.resize.ratio, k.clip.enabled && (k.original.clip || (k.original.clip = k.clip.min, k.original.clipShouldBeConverted = !0), k.inClipShouldBeConverted.clip ? (k.inClipFromCSS.clip = f.resize.clip(j, k.inClipShouldBeConverted.clip, !0), k.inClipToCSS.clip = f.resize.clip(j, k.original.clip, k.original.clipShouldBeConverted), d.fromTo(m[0], k.in.duration, k.inClipFrom, k.inClipTo, k.timeline.transitioninstart)) : g.TweenMax.set(m[0], {
                                                clip: f.resize.clip(j, k.original.clip, k.original.clipShouldBeConverted)
                                            }), f.transitions.layers.timeline.shouldRestart = !0), a.isEmptyObject(k.filter.values.in) ? a.isEmptyObject(k.filter.values.out) || j.css("filter", k.original.filter) : (k.filter.transitions.in || (k.filter.transitions.in = f.transitions.layers.filters.createTransition(k, "in", k.filter.values.in, k.filter.values.style)), d.to([{
                                                p: 0
                                            }, j[0]], k.in.duration, {
                                                p: 1,
                                                autoCSS: !1,
                                                ease: k.inLayerTo.ease,
                                                onUpdate: f.transitions.layers.filters.animate,
                                                onUpdateParams: ["{self}", k.filter.transitions.in]
                                            }, k.timeline.transitioninstart)), d.fromTo(l[0], k.in.duration, k.inLayerFrom, k.inLayerTo, k.timeline.transitioninstart), d.fromTo(j[0], k.in.duration, k.inLayerStyleFrom, k.inLayerStyleTo, k.timeline.transitioninstart)), k.is.textLayer && ((k.textIn.type || k.textOut.type) && f.transitions.layers.splitType.resetNodes(j, k), k.textIn.enabled && (k.in.enabled || d.to(l[0], 0, a.extend(!0, {}, k.inLayerTo, k.init.wrapper), k.timeline.textinstart), k.textIn.nodes = f.transitions.layers.splitType.setNodesSequence(k.textIn.type.split("_"), k.textIn.ns), f.resize.transformProperties(j, k.textInNodesFrom, k.textInShouldBeConverted), k.textInNodesFrom.transformPerspective = k.transformPerspective.text * f.resize.ratio, a.isEmptyObject(k.textInShouldBeConverted.random) || f.transitions.layers.splitType.setRandomProperties(k, k.textInShouldBeConverted.random, k.textInNodesFrom), a.isEmptyObject(k.textInNodesFrom.random) || f.transitions.layers.splitType.setRandomProperties(k, k.textInNodesFrom.random, k.textInNodesFrom), delete k.textInNodesFrom.random, k.settings.timelineIsCalculated || (k.timeline.textinstart = this.getTiming(k, k.textIn.startAt, "textinstart"), k.timeline.textinend = k.timeline.textinstart + (k.textIn.nodes.length - 1) * k.textIn.shiftNodes + k.textIn.duration), d.staggerFromTo(k.textIn.nodes, k.textIn.duration, k.textInNodesFrom, k.textInNodesTo, k.textIn.shiftNodes, k.timeline.textinstart, function(a) {
                                                f.transitions.layers.in.onComplete(a)
                                            }, [j]))), k.is.keyframe && f.o.playByScroll && d.addPause(k.timeline.allinend(), function() {
                                                setTimeout(function() {
                                                    delete f.timeouts.scroll, f.transitions.layers.timeline.timeScaleModifier = 0, f.device.scroll.timeout = 250
                                                }, 500)
                                            }), k.loop.enabled) {
                                            var p = new g.TimelineMax({
                                                repeat: k.loop.repeat,
                                                repeatDelay: k.loop.repeatDelay,
                                                yoyo: k.loop.yoyo,
                                                paused: !0
                                            });
                                            k.settings.timelineIsCalculated && !k.is.static || (k.timeline.loopstart = this.getTiming(k, k.loop.startAt, "loopstart"), k.timeline.loopend = k.loop.count !== -1 && k.timeline.loopstart + (k.loop.repeat + 1) * k.loop.duration + k.loop.repeat * k.loop.repeatDelay), k.loop._timeline = p, f.resize.transformProperties(j, k.loopToCSS, {
                                                x: k.loopLayerShouldBeConverted.x,
                                                y: k.loopLayerShouldBeConverted.y
                                            }), (k.loopToCSS.x && 0 !== k.loopToCSS.x || k.loopToCSS.y && 0 !== k.loopToCSS.y) && (f.transitions.layers.timeline.shouldRestart = !0), k.loopFromCSS.transformOrigin = f.functions.convert.transformOrigin(k.loopLayerShouldBeConverted.transformOrigin, j), k.loopFromCSS.transformPerspective = k.transformPerspective.loop * f.resize.ratio, a.isEmptyObject(k.filter.values.loop) || (k.filter.transitions.loop || (k.filter.transitions.loop = f.transitions.layers.filters.createTransition(k, "loop", a.isEmptyObject(k.filter.values.afterIn) ? k.filter.values.style : k.filter.values.afterIn, k.filter.values.loop)), p.to([{
                                                p: 0
                                            }, j[0]], k.loop.duration, {
                                                p: 1,
                                                autoCSS: !1,
                                                ease: k.loopTo.ease,
                                                onUpdate: f.transitions.layers.filters.animate,
                                                onUpdateParams: ["{self}", k.filter.transitions.loop]
                                            }, 0)), p.fromTo(n[0], k.loop.duration, k.loopFrom, k.loopTo, 0), k.loopClipShouldBeConverted.clip && (k.loopClipToCSS.clip = f.resize.clip(j, k.loopClipShouldBeConverted.clip, !0), p.to(m[0], k.loop.duration, k.loopClipTo, 0), f.transitions.layers.timeline.shouldRestart = !0), k.loop.repeat !== -1 && ("looplayers" === f.o.pauseOnHover || f.gui.timers.slidebar.$element || f.o.playByScroll) ? (d.add(p, k.timeline.loopstart), p.play()) : d.addCallback(function(a) {
                                                a.play()
                                            }, k.timeline.loopstart, [p])
                                        }
                                        k.is.static && (k.timeline.staticfrom = k.timeline.transitioninend, k.timeline.staticto = "100%", k.settings.timelineIsCalculated || (o = Math.max(k.timeline.allinandloopend(), 0), this.totalDuration = Math.max(this.totalDuration, o)));
                                        break;
                                    case "out":
                                        k.is.textLayer && k.textOut.enabled && (k.textOut.nodes = f.transitions.layers.splitType.setNodesSequence(k.textOut.type.split("_"), k.textOut.ns), f.resize.transformProperties(j, k.textOutNodesTo, k.textOutShouldBeConverted, k.textOutNodesFrom), k.textOutNodesFrom.transformPerspective = k.transformPerspective.text * f.resize.ratio, a.isEmptyObject(k.textOutShouldBeConverted.random) || f.transitions.layers.splitType.setRandomProperties(k, k.textOutShouldBeConverted.random, k.textOutNodesTo), a.isEmptyObject(k.textOutNodesTo.random) || f.transitions.layers.splitType.setRandomProperties(k, k.textOutNodesTo.random, k.textOutNodesTo), delete k.textOutNodesTo.random, k.settings.timelineIsCalculated || (k.timeline.textoutstart = this.getTiming(k, k.textOut.startAt, "textoutstart"), k.timeline.textoutend = k.timeline.textoutstart + (k.textOut.nodes.length - 1) * k.textOut.shiftNodes + k.textOut.duration), k.clip.enabled && ("undefined" == typeof k.outClipShouldBeConverted.clip && d.to(m[0], 0, {
                                            immediateRender: !1,
                                            css: {
                                                clip: f.resize.clip(j, k.clip.max)
                                            }
                                        }, k.timeline.textoutstart), f.transitions.layers.timeline.shouldRestart = !0), d.staggerFromTo(k.textOut.nodes, k.textOut.duration, k.textOutNodesFrom, k.textOutNodesTo, k.textOut.shiftNodes, k.timeline.textoutstart)), f.resize.transformProperties(j, k.outLayerToCSS, k.outLayerShouldBeConverted, k.outLayerFromCSS), f.resize.styleProperties(k.outLayerStyleFromCSS, k.outLayerStyleShouldBeConvertedFrom), f.resize.styleProperties(k.outLayerStyleToCSS, k.outLayerStyleShouldBeConvertedTo), k.outLayerFromCSS.transformPerspective = k.transformPerspective.layer * f.resize.ratio, "slidechangeonly" !== k.out.startAt ? (k.settings.timelineIsCalculated && !k.is.static || (k.is.static ? (k.timeline.staticfrom = 0, k.timeline.transitionoutstart = this.getTiming(k, k.out.startAt, "transitionoutstart", !0), k.timeline.staticto = k.timeline.transitionoutstart) : k.timeline.transitionoutstart = Math.max(this.getTiming(k, k.out.startAt, "transitionoutstart"), k.timeline.transitioninend), k.timeline.transitionoutend = k.timeline.transitionoutstart + k.out.duration), k.clip.enabled && ("undefined" == typeof k.outClipShouldBeConverted.clip ? d.to(m[0], 0, {
                                            immediateRender: !1,
                                            css: {
                                                clip: f.resize.clip(j, k.clip.max)
                                            }
                                        }, k.timeline.transitionoutstart) : (k.outClipToCSS.clip = f.resize.clip(j, k.outClipShouldBeConverted.clip, !0), d.to(m[0], k.out.duration, k.outClipTo, k.timeline.transitionoutstart)), f.transitions.layers.timeline.shouldRestart = !0), a.isEmptyObject(k.filter.values.out) || (k.filter.transitions.out || (k.filter.transitions.out = f.transitions.layers.filters.createTransition(k, "out", a.isEmptyObject(k.filter.values.afterLoop) ? a.isEmptyObject(k.filter.values.afterIn) ? k.filter.values.style : k.filter.values.afterIn : k.filter.values.afterLoop, k.filter.values.out)), d.to([{
                                            p: 0
                                        }, j[0]], k.out.duration, {
                                            p: 1,
                                            autoCSS: !1,
                                            ease: k.outLayerTo.ease,
                                            onUpdate: f.transitions.layers.filters.animate,
                                            onUpdateParams: ["{self}", k.filter.transitions.out]
                                        }, k.timeline.transitionoutstart)), d.fromTo(l[0], k.out.duration, k.outLayerFrom, k.outLayerTo, k.timeline.transitionoutstart), d.fromTo(j[0], k.out.duration, k.outLayerStyleFrom, k.outLayerStyleTo, k.timeline.transitionoutstart), d.fromTo(l[0], 0, k.init.wrapper, k.reset.wrapperOnTimelineEnd, k.timeline.transitionoutend)) : (k.timeline.staticfrom = 0, k.timeline.staticto = "100%"), (!k.is.static || k.is.static && k.settings.slideOut === f.slides.next.index) && (e.fromTo(l[0], f.o.forceLayersOutDuration, k.outLayerFrom, k.outLayerTo, 0), e.fromTo(j[0], f.o.forceLayersOutDuration, k.outLayerStyleFrom, k.outLayerStyleTo, 0), k.clip.enabled && "undefined" != typeof k.outClipShouldBeConverted.clip && (k.outClipToCSS.clip = f.resize.clip(j, k.outClipShouldBeConverted.clip, !0), e.to(m[0], f.o.forceLayersOutDuration, k.outClipTo, 0))), o = Math.max(k.timeline.alloutandloopend(), 0), this.totalDuration = Math.max(this.totalDuration, o), k.settings.timelineIsCalculated = !0
                                }
                            }
                        },
                        play: function() {
                            f.transitions._slideTimeline && (f.transitions._slideTimeline.play(), f.functions.setStates(this, {
                                started: !0,
                                running: !0,
                                stopped: !1,
                                paused: !1
                            }))
                        },
                        pause: function(b) {
                            var b = a.isNumeric(b) ? b : .75;
                            f.transitions._slideTimeline && (g.TweenMax.to(f.transitions._slideTimeline, b, {
                                timeScale: 0
                            }), f.functions.setStates(this, {
                                paused: !0,
                                stopped: !1
                            }))
                        },
                        resume: function() {
                            f.transitions._slideTimeline && (g.TweenMax.to(f.transitions._slideTimeline, .75, {
                                timeScale: 1
                            }), f.functions.setStates(this, {
                                paused: !1,
                                stopped: !1
                            }))
                        },
                        reverse: function() {
                            f.transitions._slideTimeline && f.transitions._slideTimeline.reverse()
                        },
                        scrollForward: function() {
                            if (this.play(), this.modifyTimeScale(), f.transitions._slideTimeline && !f.slider.isBusy() && (0 === f.transitions._slideTimeline.totalDuration() || 1 === f.transitions._slideTimeline.progress()) && "down" === f.device.scroll.direction) {
                                var a = f.slideshow.sequence.normalized,
                                    b = a.indexOf(f.slides.current.index);
                                b === a.length - 1 ? (f.slider.positionToViewport = "under", f.device.scroll.enable()) : f.navigation.next()
                            }
                        },
                        scrollBackwards: function() {
                            if (this.reverse(), this.modifyTimeScale(), f.transitions._slideTimeline && !f.slider.isBusy() && (0 === f.transitions._slideTimeline.totalDuration() || 0 === f.transitions._slideTimeline.progress()) && "up" === f.device.scroll.direction) {
                                var a = f.slideshow.sequence.normalized,
                                    b = a.indexOf(f.slides.current.index);
                                0 === b ? (f.slider.positionToViewport = "over", f.device.scroll.enable()) : f.navigation.prev()
                            }
                        },
                        modifyTimeScale: function() {
                            if (f.transitions._slideTimeline) {
                                var a = this;
                                g.TweenMax.to(f.transitions._slideTimeline, .25, {
                                    timeScale: 1 + a.timeScaleModifier
                                })
                            }
                        },
                        resetStates: function() {
                            this.state = {
                                started: !1,
                                running: !1,
                                paused: !1,
                                stopped: !1,
                                finished: !1
                            }
                        }
                    }, hover: {
                        enable: function(a) {
                            a.attr("data-canhover", "1")
                        },
                        disable: function(a) {
                            a.attr("data-canhover", "0")
                        },
                        set: function(a, b) {
                            b.elements.$wrapper.on("mouseenter." + e, function() {
                                f.transitions.layers.hover.mouseEnter(a, b)
                            }), b.elements.$wrapper.on("mouseleave." + e, function() {
                                f.transitions.layers.hover.mouseLeave(a, b)
                            }), b.elements.$wrapper.on("mousemove." + e, function() {
                                f.transitions.layers.hover.mouseMove(a, b)
                            })
                        },
                        createTimeline: function(a, b) {
                            if (b.hover._timeline = new g.TimelineMax({
                                    paused: !0,
                                    onReverseComplete: function(a, b) {
                                        b.hover._timeline._reversed && (b.hover._timeline.stop().clear(), delete b.hover._timeline)
                                    },
                                    onReverseCompleteParams: [a, b]
                                }), f.resize.transformProperties(a, b.hoverToCSS, b.hoverShouldBeConverted, b.hoverFromCSS), f.resize.styleProperties(b.hoverToCSS, b.hoverShouldBeConverted), b.hoverFromCSS.transformPerspective = b.transformPerspective.hover * f.resize.ratio, b.hover._tween = g.TweenMax.fromTo(a[0], b.hover.durationIn, b.hoverFrom, b.hoverTo), b.hover._timeline.add(b.hover._tween, 0), b.hover.alwaysOnTop) {
                                var c = {
                                    zIndex: 9999
                                };
                                f.browser.isSafari && (c.transform = "translateZ(999999px)"), b.hover._timeline.to(b.elements.$outerWrapper[0], b.hover.durationIn, {
                                    autoCSS: !1,
                                    css: c
                                }, 0)
                            }
                            b.hover.reverseTimeScale = b.hover.durationIn / b.hover.durationOut === 1 ? 1 : b.hover.durationIn / b.hover.durationOut, this.hoverIn(a, b)
                        },
                        mouseEnter: function(a, b) {
                            "1" === a.attr("data-canhover") && (b.elements.$wrapper.off("mousemove." + e), b.hover._timeline ? (b.hover._timeline.play().stop().progress(0), this.hoverIn(a, b)) : this.createTimeline(a, b))
                        },
                        mouseLeave: function(a, b) {
                            b.hover._timeline && (b.hover._timeline.stop().progress(1), this.hoverOut(a, b))
                        },
                        mouseMove: function(a, b) {
                            this.mouseEnter(a, b)
                        },
                        hoverIn: function(a, b) {
                            b.hover._tween.updateTo({
                                ease: b.hover.easeIn
                            }), b.hover._timeline.play().timeScale(1)
                        },
                        hoverOut: function(a, b) {
                            b.hover._tween.updateTo({
                                ease: b.hover.easeOut
                            }), b.hover._timeline.reverse().timeScale(b.hover.reverseTimeScale)
                        }
                    }, parallax: {
                        defaultProperties: {
                            type: "2d",
                            event: "cursor",
                            x: !0,
                            y: !0,
                            rotation: 10,
                            distance: 10,
                            durationMove: 1.5,
                            durationLeave: 1.2,
                            transformOrigin: "50% 50% 0",
                            transformPerspective: 500
                        },
                        defaults: {
                            scrollModifier: 5,
                            centerLayers: "center",
                            centerDegree: 40,
                            sensitive: 10
                        },
                        state: {
                            enabled: !1,
                            ready: !1
                        },
                        wrappers: {
                            cursor: {
                                $2d: a(),
                                $3d: a()
                            },
                            scroll: {
                                $2d: a(),
                                $3d: a()
                            }
                        },
                        init: function() {
                            var b = this;
                            c.on("mouseenter." + e, function() {
                                (b.wrappers.cursor.$2d.length || b.wrappers.cursor.$3d.length) && b.calculateTransformProperties()
                            }), c.on("mousemove." + e, function(a) {
                                (b.wrappers.cursor.$2d.length || b.wrappers.cursor.$3d.length) && b.mouseMove(a)
                            }), c.on("mouseleave." + e, function() {
                                (b.wrappers.cursor.$2d.length || b.wrappers.cursor.$3d.length) && b.reset()
                            }), f.device.isMobile && f.device.supportOrientation && (a(window).on("deviceorientation." + e, function() {
                                b.state.ready && b.deviceTurn(event)
                            }), a(window).on("orientationchange." + e, function() {
                                b.calculateTransformProperties()
                            })), a(window).on("scroll.parallax" + e + " touchmove.parallax" + e, function() {
                                (b.wrappers.scroll.$2d.length || b.wrappers.scroll.$3d.length) && b.scroll()
                            }), b.defaults.scrollModifier *= f.o.parallaxScrollReverse ? -1 : 1
                        },
                        addLayer: function(b, c, d, e) {
                            switch (this.state.enabled || (f.functions.setStates(this, {
                                enabled: !0
                            }), this.init()), a.extend(!0, c, this.defaultProperties, f.slides[e].parallax, d.parallax), d.transformPerspective.parallax ? c.transformPerspective = d.transformPerspective.parallax : d.transformPerspective.parallax = c.transformPerspective, c.event.match(/(cursor|scroll)/) || (c.event = "cursor"), c.type.match(/(2d,3d)/) && (c.type = "2d"), c.axis) {
                                case "none":
                                    c.x = !1, c.y = !1;
                                    break;
                                case "x":
                                    c.y = !1;
                                    break;
                                case "y":
                                    c.x = !1
                            }
                            this.wrappers[c.event]["$" + c.type] = this.wrappers[c.event]["$" + c.type].add(b)
                        },
                        addShadow: function() {
                            var b = f.gui.shadow.$element,
                                c = f.slides.current && f.slides.current.parallax ? f.slides.current.index : f.slides.next.index;
                            if (f.slides[c].data.$background && f.slides[c].data.$background.data(f.defaults.init.dataKey).parallax.enabled && f.slides[c].data.overflow && "hidden" !== f.slides[c].data.overflow) {
                                var h, d = "50% -" + .25 * f.slider.height + "px 0",
                                    e = f.slides[c].data.$background.data(f.defaults.init.dataKey).parallax;
                                h = "undefined" != typeof e.rotation ? 2 * e.rotation : "undefined" != typeof f.slides[c].parallax.rotation ? 2 * f.slides[c].parallax.rotation : 2 * this.defaultProperties.rotation, b.data(f.defaults.init.dataKey, {
                                    parallax: a.extend(!0, {}, this.defaultProperties, f.slides[c].parallax, {
                                        level: e.level,
                                        transformOrigin: d,
                                        rotation: h
                                    })
                                }), b.attr("data-parallax", "active"), g.TweenMax.set(b[0], {
                                    transformOrigin: d,
                                    transformPerspective: b.data(f.defaults.init.dataKey).parallax.transformPerspective * f.resize.ratio
                                }), "3d" === f.slides[c].parallax.type || "3d" === e.type ? this.wrappers.cursor.$3d = this.wrappers.cursor.$3d.add(b) : this.wrappers.cursor.$2d = this.wrappers.cursor.$2d.add(b)
                            }
                            this.shadowIsChecked = !0
                        },
                        removeShadow: function() {
                            var a = f.gui.shadow.$element;
                            this.wrappers.cursor.$2d = this.wrappers.cursor.$2d.not(a), this.wrappers.cursor.$3d = this.wrappers.cursor.$3d.not(a), a.attr("data-parallax", "disabled"), this.shadowIsChecked = !1
                        },
                        calculateTransformProperties: function() {
                            var b = a().add(this.wrappers.cursor.$2d).add(this.wrappers.cursor.$3d).add(this.wrappers.scroll.$2d).add(this.wrappers.scroll.$3d);
                            b.each(function() {
                                var b = a(this).data(f.defaults.init.dataKey).parallax;
                                g.TweenMax.set(a(this)[0], {
                                    transformOrigin: f.functions.convert.transformOrigin(b.transformOrigin, a(this), f.slider.$layersWrapper),
                                    transformPerspective: b.transformPerspective * f.resize.ratio
                                })
                            }), this.transformPropertiesCalculated = !0
                        },
                        deviceTurn: function(a) {
                            if (this.transformPropertiesCalculated) {
                                var c, d, b = window.orientation;
                                0 === b ? (c = 5 * -parseInt(a.gamma) * this.defaults.sensitive * f.resize.ratio, d = 5 * (this.defaults.centerDegree - parseInt(a.beta)) * this.defaults.sensitive * f.resize.ratio) : 90 === b ? (c = 5 * -parseInt(a.beta) * this.defaults.sensitive * f.resize.ratio, d = 5 * (parseInt(a.gamma) + this.defaults.centerDegree) * this.defaults.sensitive * f.resize.ratio) : (c = 5 * parseInt(a.beta) * this.defaults.sensitive * f.resize.ratio, d = 5 * (this.defaults.centerDegree - parseInt(a.gamma)) * this.defaults.sensitive * f.resize.ratio), this.animate2D(c, d, "cursor"), this.animate3D(c, d, "cursor")
                            } else this.calculateTransformProperties();
                            f.slider.state.animatingSlides || this.shadowIsChecked || !f.gui.shadow.$element || this.addShadow()
                        },
                        trigger: function() {
                            a(window).trigger("scroll.parallax" + e), a(window).trigger("touchmove.parallax" + e)
                        },
                        scroll: function() {
                            var a = "top" === this.defaults.centerLayers ? f.device.winScrollTop : f.device.winScrollTop + (f.device.viewportHeight - f.slider.height) / 2,
                                b = (a - f.slider.offsetTop) * f.resize.ratio * this.defaults.scrollModifier;
                            f.slider.state.inFullscreen && (b = 0), this.transformPropertiesCalculated || this.calculateTransformProperties(), this.animate2D(0, b, "scroll"), this.animate3D(0, b, "scroll")
                        },
                        mouseMove: function(a) {
                            if (this.transformPropertiesCalculated) {
                                f.slider.state.animatingSlides || this.shadowIsChecked || !f.gui.shadow.$element || this.addShadow();
                                var c = f.slider.offsetLeft + f.slider.width / 2,
                                    d = f.slider.offsetTop + f.slider.height / 2,
                                    e = a.pageX - c,
                                    g = a.pageY - d;
                                this.animate2D(e, g, "cursor"), this.animate3D(e, g, "cursor")
                            } else this.calculateTransformProperties()
                        },
                        animate2D: function(b, c, d) {
                            this.wrappers[d].$2d.each(function() {
                                var d = a(this);
                                if ("active" === d.attr("data-parallax")) {
                                    var e = d.data(f.defaults.init.dataKey).parallax,
                                        h = e.x ? -b * (e.distance / 2e3) * parseInt(e.level) : 0,
                                        i = e.y ? -c * (e.distance / 2e3) * parseInt(e.level) : 0;
                                    g.TweenMax.to(d[0], e.durationMove, {
                                        x: h,
                                        y: i
                                    })
                                }
                            })
                        },
                        animate3D: function(b, c, d) {
                            this.wrappers[d].$3d.each(function() {
                                var d = a(this);
                                if ("active" === d.attr("data-parallax")) {
                                    var h, i, j, k, e = d.data(f.defaults.init.dataKey).parallax;
                                    e.x ? (i = -b / (4e3 / e.rotation), j = -b * (e.distance / 2e3) * parseInt(e.level)) : (i = 0, j = 0), e.y ? (h = c / (4e3 / e.rotation), k = -c * (e.distance / 2e3) * parseInt(e.level)) : (h = 0, k = 0), g.TweenMax.to(d[0], e.durationMove, {
                                        rotationX: h,
                                        rotationY: i,
                                        x: j,
                                        y: k
                                    })
                                }
                            })
                        },
                        reset: function() {
                            var c = a().add(this.wrappers.cursor.$2d).add(this.wrappers.cursor.$3d);
                            c.each(function() {
                                var b = a(this);
                                "active" === b.attr("data-parallax") ? g.TweenMax.to(b[0], a(this).data(f.defaults.init.dataKey).parallax.durationLeave, {
                                    x: 0,
                                    y: 0,
                                    rotationX: 0,
                                    rotationY: 0
                                }) : g.TweenMax.set(b[0], {
                                    x: 0,
                                    y: 0,
                                    rotationX: 0,
                                    rotationY: 0
                                })
                            }), f.gui.shadow.$element && this.removeShadow(), this.transformPropertiesCalculated = !1
                        }
                    }, filters: {
                        createTransition: function(a, b, c, d) {
                            var h, e = new f.defaults.layer.properties.filter,
                                g = {};
                            for (h in e) switch (b) {
                                case "in":
                                    g[h] = [e[h], e[h]], g[h][0] = c.hasOwnProperty(h) ? c[h] : d.hasOwnProperty(h) ? d[h] : e[h], g[h][1] = d.hasOwnProperty(h) ? d[h] : e[h], a.filter.values.afterIn[h] = g[h][1];
                                    break;
                                case "hover":
                                case "loop":
                                case "out":
                                    g[h] = [], g[h][0] = c.hasOwnProperty(h) ? c[h] : e[h], g[h][1] = d.hasOwnProperty(h) ? d[h] : c.hasOwnProperty(h) && c[h] !== e[h] ? c[h] : e[h], "loop" === b && a.loop.yoyo !== !0 && a.loop.count !== -1 && (a.filter.values.afterLoop[h] = g[h][1]);
                                    break;
                                case "bg":
                                    g[h] = [e[h], e[h]], c.hasOwnProperty(h) && (g[h][0] = c[h]), d.hasOwnProperty(h) && (g[h][1] = d[h])
                            }
                            return g
                        },
                        convert: function(a) {
                            a = a.split(" ");
                            for (var c, d, e, b = {}, f = /(blur|brightness|contrast|grayscale|hue-rotate|invert|saturate|sepia)/i, g = 0, h = a.length; g < h; g++) e = a[g].split("("), c = e[0], c.match(f) && (d = parseInt(e[1]), b[c] = d);
                            return b
                        },
                        animate: function(a, b) {
                            var d, c = 100 * a.target[0].p;
                            if ("object" == typeof b) {
                                var e = "";
                                for (var f in b)
                                    if ("object" == typeof b[f] && 2 === b[f].length) switch (f) {
                                        case "blur":
                                            d = b[f][0] < b[f][1] ? b[f][0] + Math.abs(b[f][0] - b[f][1]) / 100 * c : b[f][0] - Math.abs(b[f][0] - b[f][1]) / 100 * c, e += " blur( " + d + "px )";
                                            break;
                                        case "hue-rotate":
                                            d = b[f][0] < b[f][1] ? b[f][0] + Math.abs(b[f][0] - b[f][1]) / 100 * c : b[f][0] - Math.abs(b[f][0] - b[f][1]) / 100 * c, e += " hue-rotate( " + d + "deg )";
                                            break;
                                        default:
                                            d = b[f][0] < b[f][1] ? b[f][0] + Math.abs(b[f][0] - b[f][1]) / 100 * c : b[f][0] - Math.abs(b[f][0] - b[f][1]) / 100 * c, e += " " + f + "( " + d + "% )"
                                    }
                                    g.TweenMax.set(a.target, {
                                    "-webkit-filter": e,
                                    filter: e
                                })
                            }
                        }
                    }, splitType: {
                        setNodesSequence: function(a, b) {
                            var c = b;
                            if ("desc" == a[1]) c = b.slice(0).reverse();
                            else if ("rand" == a[1]) c = b.slice(0).sort(function() {
                                return .5 - Math.random()
                            });
                            else if ("center" == a[1]) {
                                var d, e = Math.floor(b.length / 2);
                                for (c = [b[e]], d = 1; d <= e; d++) c.push(b[e - d], b[e + d]);
                                c.length = b.length
                            } else if ("edge" == a[1]) {
                                var f, g = Math.floor(b.length / 2);
                                for (c = [b[0]], f = 1; f <= g; f++) c.push(b[b.length - f], b[f]);
                                c.length = b.length
                            }
                            return c
                        },
                        resetNodes: function(b, c) {
                            a(".char, .word, .line", b).add(c.elements.$wrapper).css({
                                transform: "none",
                                opacity: 1
                            }).each(function() {
                                delete this._gsTransform
                            })
                        },
                        setRandomProperties: function(a, b, c) {
                            for (var d in b) {
                                for (var e = [], g = 0, h = a.textIn.nodes.length; g < h; g++) e[g] = f.functions.convert.randomProperties(b[d], d);
                                delete c[d], c.cycle[d] = e
                            }
                            b = null
                        }
                    }
                },
                media: {
                    defaults: {
                        delay: 500,
                        fadeIn: 500,
                        fadeOut: 750
                    },
                    changeBackgroundVideo: function(a, b) {
                        if (f.slides.current.index && f.slides.current.data.$backgroundVideo.length) {
                            var d = f.slides.current.data.$backgroundVideo,
                                e = d.data(f.defaults.init.dataKey).elements.$bgWrapper;
                            b && (d.data(f.defaults.init.dataKey).mediaProperties.willBePaused = !0, e.fadeOut(f.transitions.media.defaults.fadeOut, function() {
                                d.trigger("stopBackgroundVideo"), d.data(f.defaults.init.dataKey).mediaProperties.willBePaused = !1
                            }))
                        }
                        if (f.slides.next.data.$backgroundVideo.length) {
                            var g = f.slides.next.data.$backgroundVideo,
                                h = g.data(f.defaults.init.dataKey).elements.$bgWrapper,
                                i = g.data(f.defaults.init.dataKey).elements.$bgOuterWrapper;
                            f.device.isMobile && (c.hasClass("ls-device-is-phone") && i.hasClass("ls-hide-on-phone") || c.hasClass("ls-device-is-tablet") && i.hasClass("ls-hide-on-tablet")) || setTimeout(function() {
                                g.trigger("playBackgroundVideo")
                            }, a ? 50 : 0), a || b ? h.fadeIn(f.transitions.media.defaults.fadeOut) : h.css({
                                display: "block"
                            }), g.data(f.defaults.init.dataKey).mediaProperties.isPreloaded = !0
                        }
                    }
                },
                timers: {
                    defaults: {
                        fadeInDuration: .35,
                        reverseDuration: .3
                    },
                    create: function(a) {
                        this.curNext = a || "next", this.reset(), f.gui.timers.bar.$element && this.bar.createTransition(), f.gui.timers.circle.$element && this.circle.createTransition(), f.gui.timers.slidebar.$element && this.slidebar.createTransition()
                    },
                    reverse: function() {
                        if (f.slides.current && f.slides.current.data && f.transitions._slideTimeline) {
                            var a = f.transitions._slideTimeline.progress(),
                                b = f.slides.current.data.duration * a / this.defaults.reverseDuration;
                            f.gui.timers.bar.$element && this.bar._transition && (f.transitions._slideTimeline.remove(f.transitions.timers.bar._transition), this.bar._transition.reverse().timeScale(b)), f.gui.timers.circle.$element && this.circle._transition && (f.transitions._slideTimeline.remove(f.transitions.timers.circle._transition), this.circle._transition.reverse().timeScale(b)), f.gui.timers.slidebar.$element && this.slidebar._transition && (f.transitions._slideTimeline.remove(f.transitions.timers.slidebar._transition), this.slidebar._transition.reverse().timeScale(b))
                        }
                    },
                    reset: function() {
                        f.gui.timers.bar.$element && this.bar._transition && this.bar.reset(), f.gui.timers.circle.$element && this.circle._transition && this.circle.reset(), f.gui.timers.slidebar.$element && this.slidebar._transition && this.slidebar.reset()
                    },
                    bar: {
                        reset: function() {
                            this._transition && (this._transition.kill(), this._transition = !1)
                        },
                        createTransition: function() {
                            this._transition = g.TweenMax.fromTo(f.gui.timers.bar.$element[0], f.slides[f.transitions.curNext].data.duration, {
                                autoCSS: !1,
                                paused: !0,
                                css: {
                                    width: 0
                                }
                            }, {
                                autoCSS: !1,
                                css: {},
                                ease: g.Linear.easeNone,
                                onReverseComplete: function() {
                                    f.transitions.timers.bar._transition = !1
                                },
                                onComplete: function(a) {
                                    a.target.style.width = "100%", a.target.style.width = "calc( 100% - " + f.slider.initial.skinWidth + "px )"
                                },
                                onCompleteParams: ["{self}"],
                                onUpdate: function(a) {
                                    a.target.style.width = Math.min(f.slider.width, f.slider.width * a.progress()) + "px"
                                },
                                onUpdateParams: ["{self}"]
                            })
                        }
                    },
                    circle: {
                        reset: function() {
                            this._transition && (f.gui.timers.circle.$element.stop(!0, !0), this._transition.kill(), this._transition = !1)
                        },
                        createTransition: function() {
                            var a = f.gui.timers.circle.$element.find(".ls-ct-right .ls-ct-rotate")[0],
                                b = f.gui.timers.circle.$element.find(".ls-ct-left .ls-ct-rotate")[0],
                                c = f.slides[f.transitions.curNext].data.duration;
                            this._transition = new g.TimelineMax({
                                paused: !0
                            }).fromTo(f.gui.timers.circle.$element[0], f.transitions.timers.defaults.fadeInDuration, {
                                autoCSS: !1,
                                immediateRender: !0,
                                css: {
                                    opacity: 0,
                                    display: "block"
                                }
                            }, {
                                autoCSS: !1,
                                css: {
                                    opacity: f.gui.timers.circle.$element.data("original").opacity
                                }
                            }).fromTo(a, c / 2, {
                                autoCSS: !1,
                                css: {
                                    rotation: 0
                                }
                            }, {
                                autoCSS: !1,
                                css: {
                                    rotation: 180
                                },
                                ease: g.Linear.easeNone
                            }, 0).fromTo(b, c / 2, {
                                autoCSS: !1,
                                css: {
                                    rotation: 0
                                }
                            }, {
                                autoCSS: !1,
                                css: {
                                    rotation: 180
                                },
                                ease: g.Linear.easeNone
                            }, c / 2)
                        }
                    },
                    slidebar: {
                        reset: function() {
                            this._transition && (this._transition.kill(), this._transition = !1)
                        },
                        createTransition: function() {
                            var b = this;
                            b._transition = new g.TimelineMax({
                                paused: !0,
                                onReverseComplete: function() {
                                    f.transitions.timers.slidebar._transition = !1
                                }
                            }), a.each(f.gui.timers.slidebar.$sliderContainerElement, function(a, c) {
                                b._transition.add(g.TweenMax.fromTo(f.gui.timers.slidebar.$sliderContainerElement[a][0], f.slides[f.transitions.curNext].data.duration, {
                                    autoCSS: !1,
                                    css: {
                                        left: 0
                                    }
                                }, {
                                    autoCSS: !1,
                                    css: {},
                                    ease: g.Linear.easeNone,
                                    onComplete: function(b) {
                                        b.target.style.left = "calc( 100% - " + f.gui.timers.slidebar.sliderContainerElementWidth[a] + "px )"
                                    },
                                    onCompleteParams: ["{self}"],
                                    onUpdate: function(b) {
                                        b.target.style.left = (f.gui.timers.slidebar.containerElementWidth[a] - f.gui.timers.slidebar.sliderContainerElementWidth[a]) * b.progress() + "px"
                                    },
                                    onUpdateParams: ["{self}"]
                                }), 0), b._transition.add(g.TweenMax.fromTo(f.gui.timers.slidebar.$progressBarElement[a][0], f.slides[f.transitions.curNext].data.duration, {
                                    autoCSS: !1,
                                    css: {
                                        width: 0
                                    }
                                }, {
                                    autoCSS: !1,
                                    css: {},
                                    ease: g.Linear.easeNone,
                                    onComplete: function(a) {
                                        a.target.style.width = "100%"
                                    },
                                    onCompleteParams: ["{self}"],
                                    onUpdate: function(b) {
                                        b.target.style.width = f.gui.timers.slidebar.elementWidth[a] * b.progress() + "px"
                                    },
                                    onUpdateParams: ["{self}"]
                                }), 0)
                            })
                        }
                    }
                }
            }, f.plugins = {
                load: function() {
                    if (f.o.plugins && 0 !== f.o.plugins.length) {
                        var b = f.o.plugins[0],
                            c = "object" == typeof b ? b.namespace : b;
                        if (window._layerSlider.plugins[c]) f.plugins.init(c, b, !0), f.plugins.load();
                        else if (f.browser.usesFileProtocol || "object" != typeof b) f.browser.usesFileProtocol ? (window.console && (console.error(f.defaults.slider.errorText, "Cannot load plugins on file:// protocol."), console.info("Please include the plugin files manually.")), f.o.plugins.splice(0, 1), f.plugins.load()) : (window.console && (console.error(f.defaults.slider.errorText, "Plugin files are missing!"), console.info('Plugin "' + c + '" has been added in slider init options, but the source files are not found on page.')), f.o.plugins.splice(0, 1), f.plugins.load());
                        else {
                            if (window._layerSlider.pluginsBeingLoaded.indexOf(c) !== -1) return void f.plugins.checkLoaded(c);
                            window._layerSlider.pluginsLoaded.indexOf(c) === -1 && window._layerSlider.pluginsNotLoaded.indexOf(c) === -1 ? (window._layerSlider.pluginsBeingLoaded.push(c), a.ajax({
                                url: b.js.indexOf("http://") === -1 && b.js.indexOf("https://") === -1 ? (window._layerSlider.pluginsPath ? window._layerSlider.pluginsPath : window._layerSlider.scriptPath + "/../plugins/") + b.js : b.js,
                                dataType: "script",
                                success: function() {
                                    f.plugins.init(b.namespace, b, !0), window._layerSlider.pluginsLoaded.push(c)
                                },
                                error: function(a, b, d) {
                                    window.console && (console.error(f.defaults.slider.errorText, c, "plugin has not been loaded!"), console.error("Additional error info:", d)), window._layerSlider.pluginsNotLoaded.push(c)
                                },
                                complete: function() {
                                    window._layerSlider.pluginsBeingLoaded.splice(window._layerSlider.pluginsBeingLoaded.indexOf(c), 1), f.plugins.load()
                                }
                            })) : (f[c] || window._layerSlider.pluginsNotLoaded.indexOf(c) !== -1 ? f.o.plugins.splice(0, 1) : f.plugins.init(c, b), f.plugins.load())
                        }
                    } else f.slider.check.initialized()
                },
                init: function(b, d, g) {
                    f.initializedPlugins[b] = new window._layerSlider.plugins[b](f, c, e, d.settings), window._layerSlider.checkVersions(f.initializedPlugins[b].pluginData.requiredLSVersion, f.plugin.version) ? (d.css && g && a('<link rel="stylesheet" href="' + (d.css.indexOf("http://") === -1 && d.css.indexOf("https://") === -1 ? (window._layerSlider.pluginsPath ? window._layerSlider.pluginsPath : window._layerSlider.scriptPath + "/../plugins/") + d.css : d.css) + '">').appendTo("head"), f.initializedPlugins[b].init && f.initializedPlugins[b].init()) : window.console && console.error(f.defaults.slider.errorText, b, "plugin has not been loaded! Required LayerSlider version:", f.initializedPlugins[b].pluginData.requiredLSVersion, "(you have:", f.plugin.version + ")"), f.o.plugins.splice(0, 1)
                },
                checkLoaded: function(a) {
                    f.intervals.pluginLoaded = setInterval(function() {
                        window._layerSlider.pluginsLoaded.indexOf(a) === -1 && window._layerSlider.pluginsNotLoaded.indexOf(a) === -1 || window._layerSlider.pluginsBeingLoaded.indexOf(a) !== -1 || (clearInterval(f.intervals.pluginLoaded), delete f.intervals.pluginLoaded, f.plugins.load())
                    }, 100)
                }
            }, f.slider = {
                shouldResize: !0,
                thumbnails: [],
                state: {
                    preloadingImages: !1,
                    changingSlides: !1,
                    animatingSlides: !1
                },
                isPaused: !1,
                isBusy: function() {
                    return this.state.preloadingImages || this.state.changingSlides || this.state.animatingSlides
                },
                load: function() {
                    return !!document.body.contains(b) && (f.api.hasEvent("sliderWillLoad") && c.triggerHandler("sliderWillLoad"), void f.slider.set.global())
                },
                set: {
                    global: function() {
                        if (f.originalMarkup = c[0].outerHTML, f.userInitOptions = f.functions.convert.properties(f.functions.convert.oldProperties(d)), f.meta = {}, f.o = a.extend(!0, {}, f.defaults.init.options, f.userInitOptions), f.o.forceLayersOutDuration /= 1e3, f.o.forceLayersOutDuration = f.o.forceLayersOutDuration > 0 ? f.o.forceLayersOutDuration : .75, f.o.sliderFadeInDuration /= 1e3, window.console && f.o.hideWelcomeMessage !== !0 && window._layerSlider.hideWelcomeMessage !== !0) {
                            window._layerSlider.hideWelcomeMessage = !0;
                            var b = window.console.info ? "info" : "log";
                            console[b]("LayerSlider", "v" + f.plugin.version, "initialized"), console[b]("Find updates and docs @ https://layerslider.kreaturamedia.com/")
                        }
                        var e = {
                            namespace: "debug",
                            js: "debug/layerslider.debug.js",
                            css: "debug/layerslider.debug.css"
                        };
                        document.location.hash.indexOf("debug") !== -1 && window.console && (document.location.hash.indexOf("url=") !== -1 && (window._layerSlider.pluginsPath = document.location.hash.split("url=")[1].split("&")[0], e.js = window._layerSlider.pluginsPath + "debug/layerslider.debug.js", e.css = window._layerSlider.pluginsPath + "debug/layerslider.debug.css"), "object" == typeof f.o.plugins ? f.o.plugins.push(e) : f.o.plugins = [e]), (window._layerSlider.currentScript || window._layerSlider.lsScript) && (window._layerSlider.scriptPath = (window._layerSlider.currentScript || window._layerSlider.lsScript).src.replace(/\\/g, "/").replace(/\/[^\/]*$/, "")), "object" == typeof f.o.plugins ? f.plugins.load() : f.slider.check.initialized()
                    },
                    styles: function() {
                        var j, k, l, m, r, s, t, w, x, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, d = f.slider,
                            g = c.parent(),
                            h = b.style,
                            i = window.getComputedStyle(b, null),
                            n = parseInt(b.clientWidth),
                            o = parseInt(b.clientHeight),
                            p = parseInt(g.width()),
                            q = parseInt(g.height()),
                            u = f.o.layersContainerWidth,
                            v = f.o.layersContainerHeight,
                            A = f.o.type.toLowerCase();
                        switch (f.debugMode && f.debug.add("group", "sliderInit.style"), f.o.width ? j = f.o.width.indexOf("%") == -1 ? parseInt(f.o.width) : f.o.width : h.width ? j = h.width.indexOf("%") == -1 ? parseInt(h.width) : h.width : u > 0 ? (j = u, f.debugMode && f.debug.add("warn", "sliderInit.noWidth", u)) : (j = n, f.debugMode && f.debug.add("warn", "sliderInit.noWidth2", n)), l = j, f.o.height ? k = f.o.height.indexOf("%") == -1 ? parseInt(f.o.height) : f.o.height : h.height ? k = h.height.indexOf("%") == -1 ? parseInt(h.height) : h.height : v > 0 ? (k = v, f.debugMode && f.debug.add("warn", "sliderInit.noHeight", v)) : (k = o, f.debugMode && f.debug.add("warn", "sliderInit.noHeight2", q)), m = k, r = "" !== h.maxWidth ? h.maxWidth.indexOf("%") === -1 ? parseInt(h.maxWidth) : h.maxWidth : 0, "undefined" == typeof f.userInitOptions.type && (u > 0 && v > 0 || "100%" === j && "100%" === k ? A = "fullsize" : u <= 0 && v <= 0 && f.o.responsiveUnder <= 0 ? A = "undefined" != typeof f.o.responsive && f.o.responsive === !1 ? "fixedsize" : "responsive" : f.o.responsiveUnder > 0 && (A = "fullwidth")), A) {
                            case "responsive":
                                f.o.responsiveUnder = -1, j.indexOf("%") !== -1 && (j = n, f.debugMode && f.debug.add("warn", "sliderInit.percWidth", [A, j, n])), k.indexOf("%") !== -1 && (j = o, f.debugMode && f.debug.add("warn", "sliderInit.responsive", [A, k, o])), f.debugMode && u > 0 && f.debug.add("warn", "sliderInit.conWidth2", [A, u]), f.debugMode && v > 0 && f.debug.add("warn", "sliderInit.conHeight2", [A, v]);
                                break;
                            case "fullwidth":
                                j.indexOf("%") !== -1 && (f.debugMode && f.debug.add("warn", "sliderInit.percWidth", [A, j, n]), j = n), u <= 0 && (u = j, f.debugMode && f.debug.add("warn", "sliderInit.conWidth", [A, j])), f.o.responsiveUnder <= 0 && (f.o.responsiveUnder = u, f.debugMode && f.debug.add("warn", "sliderInit.fullwidth", u)), k.indexOf("%") !== -1 && (t = q / (100 / parseInt(k)), f.debugMode && f.debug.add("warn", "sliderInit.fullwidth2", [A, k, t]), k = t), v <= 0 && (v = k);
                                break;
                            case "fullsize":
                                j.indexOf("%") !== -1 && (s = u > 0 ? u : p, f.debugMode && f.debug.add("warn", "sliderInit.fullsize", [A, j, s, p, u]), j = s), u <= 0 && (u = j, f.debugMode && f.debug.add("warn", "sliderInit.conWidth", [A, j])), k.indexOf("%") !== -1 && (t = v > 0 ? v : a(window).height() / (100 / parseInt(k)), f.debugMode && f.debug.add("warn", "sliderInit.fullsize2", [A, k, t, a(window).height(), v]), k = t), v <= 0 && (v = k, f.debugMode && f.debug.add("warn", "sliderInit.conHeight", [A, k]));
                                break;
                            case "fixedsize":
                        }
                        c.addClass("ls-container ls-" + A), c.parent().addClass("ls-direction-fix"), f.o.preventSliderClip && f.o.fitScreenWidth && ("fullwidth" === A || "fullsize" === A && "fitheight" !== f.o.fullSizeMode) && c.parents(":not(body, html)").each(function() {
                            a(this).addClass("ls-overflow-visible")
                        }), f.userInitOptions.slideBGSize || "responsive" !== A || !f.userInitOptions.hasOwnProperty("sliderVersion") || f.userInitOptions.sliderVersion || (f.o.slideBGSize = "auto", f.debugMode && f.debug.add("warn", "sliderInit.bgCover", A)), f.o.slideBGSize.replace("100% 100%", "stretch"), w = u > 0 ? u : j, x = v > 0 ? v : k, D = b.style.marginLeft, "auto" === D ? B = "auto" : "" === D ? B = parseInt(i.getPropertyValue("margin-left")) : (B = parseInt(b.style.marginLeft), F = !0), E = b.style.marginRight, "auto" === E ? C = "auto" : "" === E ? C = parseInt(i.getPropertyValue("margin-right")) : (C = parseInt(b.style.marginRight), G = !0), B === C && ("" === D && "" === E && (H = B, B = "auto", C = "auto"), c.css({
                            marginLeft: "auto",
                            marginRight: "auto"
                        })), I = "" !== h.paddingLeft ? parseInt(h.paddingLeft) : parseInt(c.css("padding-left")), K = "" !== h.paddingRight ? parseInt(h.paddingRight) : parseInt(c.css("padding-right")), J = "" !== h.paddingTop ? parseInt(h.paddingTop) : parseInt(c.css("padding-top")), L = "" !== h.paddingBottom ? parseInt(h.paddingBottom) : parseInt(c.css("padding-bottom")), M = "" !== h.borderLeftWidth ? parseInt(h.borderLeftWidth) : parseInt(c.css("border-left-width")), O = "" !== h.borderRightWidth ? parseInt(h.borderRightWidth) : parseInt(c.css("border-right-width")), N = "" !== h.borderTopWidth ? parseInt(h.borderTopWidth) : parseInt(c.css("border-top-width")), P = "" !== h.borderBottomWidth ? parseInt(h.borderBottomWidth) : parseInt(c.css("border-bottom-width")), d.initial = {
                            type: A,
                            width: j,
                            height: k,
                            originalWidth: l,
                            originalHeight: m,
                            percW: j / 100,
                            percH: k / 100,
                            layersWidth: u,
                            layersHeight: v,
                            ratio: w / x,
                            maxWidth: r,
                            marginLeft: B,
                            marginRight: C,
                            paddingLeft: I,
                            paddingTop: J,
                            paddingRight: K,
                            paddingBottom: L,
                            borderLeftWidth: M,
                            borderTopWidth: N,
                            borderRightWidth: O,
                            borderBottomWidth: P,
                            skinWidth: I + K + M + O,
                            skinHeight: J + L + N + P
                        }, f.debugMode && (f.debug.add("log", "sliderInit.style", [j, k, l, m, u, v, parseInt(w / x * 100) / 100, r > 0 ? r : void 0, [B, C]]), H && f.debug.add("warn", "sliderInit.margin", H)), a("html").attr("id") ? a("body").attr("id") || a("body").attr("id", "ls-global") : a("html").attr("id", "ls-global"), "static" === h.position && "absolute" === h.position || (b.style.position = "relative"), f.o.insertSelector && c[f.o.insertMethod](f.o.insertSelector), f.slider.$hiddenWrapper = a('<div class="ls-wp-container fitvidsignore ls-hidden" data-layerslider-uid="' + e + '"></div>').addClass(c.attr("class")).prependTo("body"), f.slider.$innerWrapper = a('<div class="ls-inner"></div>').appendTo(c), f.slider.$layersWrapper = a('<div class="ls-layers"></div>').appendTo(f.slider.$innerWrapper), f.slider.$bgVideosWrapper = a('<div class="ls-background-videos"></div>').appendTo(f.slider.$layersWrapper), f.slider.$slideBGWrapper = a('<div class="ls-slide-backgrounds"></div>').appendTo(f.slider.$layersWrapper), f.o.hideOnMobile === !0 && f.device.isMobile ? (c.addClass("ls-forcehide"), c.closest(".ls-wp-fullwidth-container").addClass("ls-forcehide"), f.o.autoStart = !1) : f.slider.check.showHide(), f.o.globalBGImage && f.slider.$innerWrapper.css({
                            backgroundImage: "url( " + f.o.globalBGImage + " )",
                            backgroundRepeat: f.o.globalBGRepeat,
                            backgroundAttachment: f.o.globalBGAttachment,
                            backgroundSize: f.o.globalBGSize,
                            backgroundPosition: f.o.globalBGPosition
                        }), f.slider.$innerWrapper.css({
                            backgroundColor: f.o.globalBGColor
                        }), "transparent" == f.o.globalBGColor && f.o.globalBGImage === !1 && f.slider.$innerWrapper.css({
                            background: "none transparent"
                        })
                    },
                    options: function() {
                        if (a("html").find('meta[content*="WordPress"]').length && (f.meta.wpVersion = a("html").find('meta[content*="WordPress"]').attr("content").split("WordPress")[1]), a("html").find('script[src*="layerslider"]').length && a("html").find('script[src*="layerslider"]').attr("src").indexOf("?") != -1 && (f.meta.lswpVersion = a("html").find('script[src*="layerslider"]').attr("src").split("?")[1].split("=")[1]), "undefined" != typeof layerSliderTransitions && (f.t = a.extend({}, layerSliderTransitions)), "undefined" != typeof layerSliderCustomTransitions && (f.ct = a.extend({}, layerSliderCustomTransitions)), f.debugMode && ("undefined" != typeof layerCustomSliderTransitions ? (f.debug.add("log", "sliderInit.customTransitions", !1), "undefined" == typeof layerSliderTransitions && f.debug.add("warn", "sliderInit.slideTransitions")) : "undefined" == typeof layerSliderTransitions && f.debug.add("warn", "sliderInit.noSlideTransitions")), "number" == typeof f.o.parallaxCenterDegree && (f.transitions.layers.parallax.defaults.centerDegree = f.o.parallaxCenterDegree), "number" == typeof f.o.parallaxSensitivity && (f.transitions.layers.parallax.defaults.sensitive = f.o.parallaxSensitivity), f.o.parallaxCenterLayers && (f.transitions.layers.parallax.defaults.centerLayers = f.o.parallaxCenterLayers), f.o.playByScroll && (f.o.cycles = -1, f.o.startInViewport = !0, f.o.pauseOnHover = !1, f.o.autoStart = !1), f.o.startInViewport) {
                            if (f.slider.positionToViewport = f.device.winScrollTop > f.slider.offsetTop - (f.device.viewportHeight - f.slider.height) / 2 ? "under" : "over", f.o.playByScroll) {
                                var i, j, k, g = !0,
                                    h = 4 * f.o.playByScrollSpeed;
                                f.device.scroll.timeout = 250, f.transitions.layers.timeline.timeScaleModifier = 0, a(document).on("wheel." + e + " touchmove." + e, function(a) {
                                    f.device.isMobile ? (i = a.originalEvent.touches[0].clientY, i > j ? f.device.scroll.direction = "up" : i < j && (f.device.scroll.direction = "down"), k = j - i, j = i) : (a.originalEvent.deltaY > 0 ? f.device.scroll.direction = "down" : f.device.scroll.direction = "up", k = a.originalEvent.deltaY), 0 !== Math.abs(k) && (f.device.scroll.lastDirection ? f.device.scroll.lastDirection !== f.device.scroll.direction && (f.device.scroll.lastDirection = f.device.scroll.direction, f.transitions.layers.timeline.timeScaleModifier = 0) : f.device.scroll.lastDirection = f.device.scroll.direction, "inside" === f.slider.positionToViewport && (f.resize.viewport(), k >= 0 ? f.transitions.layers.timeline.scrollForward() : f.transitions.layers.timeline.scrollBackwards(), g && (clearTimeout(f.timeouts.scroll), g = !1, f.transitions.layers.timeline.timeScaleModifier = f.transitions.layers.timeline.timeScaleModifier < h ? f.transitions.layers.timeline.timeScaleModifier + .25 : h, f.timeouts.scroll2 = setTimeout(function() {
                                        delete f.timeouts.scroll2, g = !0, f.device.scroll.timeout = f.device.scroll.timeout > 50 ? f.device.scroll.timeout - 50 : 50
                                    }, f.device.scroll.timeout))))
                                })
                            }
                            a(window).on("scroll." + e, function() {
                                f.slider.check.positionToViewport()
                            }), f.timeouts.checkPosition = setTimeout(function() {
                                f.slider.check.positionToViewport()
                            }, 25)
                        }
                        f.slider.canShow = !0
                    }
                },
                check: {
                    initialized: function() {
                        f.debugMode && f.debug.add("log", "sliderInit.info", [f.plugin.version, f.plugin.releaseDate, f.userInitOptions.sliderVersion || "n/a or slider version is pre 6.0.0", c.attr("id"), e, a.fn.jquery, f.meta.lswpVersion, f.meta.wpVersion], !0), f.slider.initialized || (f.slider.initialized = !0, this.skins())
                    },
                    skins: function() {
                        f.o.skin && "" !== f.o.skin && f.o.skinsPath && "" !== f.o.skinsPath ? f.gui.skin.load() : f.slider.init()
                    },
                    showHide: function() {
                        f.device.isMobile && f.o.hideOnMobile !== !1 || (f.device.viewportWidth < f.o.hideUnder || f.device.viewportWidth > f.o.hideOver && f.o.hideOver > 0 ? f.slider.hide() : f.slider.show())
                    },
                    positionToViewport: function() {
                        if (delete f.timeouts.checkPosition, f.o.playByScroll) {
                            if (f.device.scroll.direction) {
                                var b = "down" === f.device.scroll.direction ? f.device.winScrollTop : f.slider.offsetTop - (f.device.viewportHeight - f.device.viewportHeight) / 2,
                                    c = "down" === f.device.scroll.direction ? f.slider.offsetTop - (f.device.viewportHeight - f.device.viewportHeight) / 2 : f.device.winScrollTop;
                                b > c && ("up" === f.device.scroll.direction && "under" === f.slider.positionToViewport || "down" === f.device.scroll.direction && "over" === f.slider.positionToViewport) && (f.slider.positionToViewport = "inside", f.resize.viewport(), f.device.scroll.disable())
                            }
                        } else {
                            var d = f.device.winScrollTop + f.device.viewportHeight / 2,
                                g = f.slider.offsetTop + f.slider.height / 2;
                            (Math.abs(d - g) < f.device.viewportHeight / 2 || f.device.winScrollTop < f.slider.offsetTop && f.device.winScrollTop + f.device.viewportHeight > f.slider.offsetTop + f.slider.height) && (f.slider.positionToViewport = "inside", a(window).off("scroll." + e), f.debugMode && f.debug.add("log", "slideshow.inviewport", !1), f.transitions._slideTimeline && f.transitions.layers.timeline.play())
                        }
                    }
                },
                init: function() {
                    return clearTimeout(f.timeouts.skinLoad1), clearTimeout(f.timeouts.skinLoad2), clearTimeout(f.timeouts.skinLoad3), clearTimeout(f.timeouts.skinLoad4), f.device.setBasicEvents(), f.device.fullscreen.set(), f.slider.set.styles(), f.slider.set.options(), f.slides.init(), f.media.init(), f.gui.timers.init(), f.gui.loadingIndicator.init(), f.preload.init(), f.gui.shadow.init(), f.navigation.init(), f.slideshow.init(), f.slides.set.firstSlide(), f.gui.navigation.init(), f.resize.slider(), f.yourLogo.init(), a(window).on("resize." + e, function() {
                        f.slider.check.showHide(), "inside" === f.slider.positionToViewport && f.o.playByScroll && f.resize.viewport(), f.slider.shouldResize && f.resize.all()
                    }), f.debugMode && (a(window).off(".debug" + e), a(window).on("resize.debug" + e, function() {
                        f.debug.add("log", "resize.window", f.device.viewportWidth, !0)
                    })), a(window).on("orientationchange." + e, function() {
                        f.device.getDimensions(), f.resize.all()
                    }), f.device.getDimensions(), a(window).trigger("resize"), a(window).trigger("orientationchange"), f.api.hasEvent("sliderDidLoad") && c.triggerHandler("sliderDidLoad", f.api.eventData()), f.functions.setStates(f.slider, {
                        isLoaded: !0
                    }), f.slider.state.shouldBeDestroyed ? void f.api.methods("destroy") : void f.slideshow.changeTo(f.slides.first.index)
                },
                hide: function() {
                    c.addClass("ls-forcehide"), c.closest(".ls-wp-fullwidth-container").addClass("ls-forcehide")
                },
                show: function() {
                    c.removeClass("ls-forcehide"), c.closest(".ls-wp-fullwidth-container").removeClass("ls-forcehide")
                }
            }, f.functions = {
                convert: {
                    transformOrigin: function(b, c, d) {
                        var e = a.trim(b),
                            g = e.split(" "),
                            h = "",
                            i = ["Left", "Top"],
                            j = [f.slider.width, f.slider.height];
                        e = e.replace("sliderleft", "0").replace("sliderright", "100%").replace("slidercenter", "50%").replace("slidermiddle", "50%").replace("slidertop", "0").replace("sliderbottom", "100%").replace("left", "0").replace("right", "100%").replace("center", "50%").replace("middle", "50%").replace("top", "0").replace("bottom", "100%").split(" ");
                        for (var k = 0; k < e.length; k++)
                            if (g[k].indexOf("slider") !== -1) {
                                f.transitions.layers.timeline.shouldRestart = !0;
                                var l = c.data(f.defaults.init.dataKey).elements.$wrapper[0].style;
                                h += k < 2 ? j[k] / (100 / parseInt(e[k])) - parseInt(l[i[k].toLowerCase()]) - parseInt(l["margin" + i[k]]) + "px " : "0px"
                            } else {
                                if (k < 2 && c && d) switch (k) {
                                    case 0:
                                        j = d.width();
                                        break;
                                    case 1:
                                        j = d.height()
                                }
                                h += e[k].indexOf("%") !== -1 ? k < 2 && c && d ? j / (100 / parseInt(e[k])) + "px " : e[k] + " " : parseInt(e[k]) * f.resize.ratio + "px "
                            }
                        return a.trim(h)
                    },
                    easing: function(a, b) {
                        if ("string" == typeof a) {
                            var c, d, e;
                            return a = a.toLowerCase(), a.indexOf("swing") !== -1 || a.indexOf("linear") !== -1 ? c = g.Linear.easeNone : (d = a.match(/(easeinout|easein|easeout)(.+)/)[2], e = g[d.charAt(0).toUpperCase() + d.slice(1)], a.indexOf("easeinout") !== -1 ? c = e.easeInOut : a.indexOf("easeout") !== -1 ? c = b ? e.easeIn : e.easeOut : a.indexOf("easein") !== -1 && (c = b ? e.easeOut : e.easeIn)), c
                        }
                        return a
                    },
                    transition: function(b, c, d, e) {
                        var g = a.extend({}, b),
                            h = {
                                rotate: "rotation",
                                rotateX: "rotationX",
                                rotateY: "rotationY"
                            };
                        return a.each(h, function(a, b) {
                            a in g && (g[b] = g[a], delete g[a])
                        }), "after" === d ? g.scaleX = g.scaleY = g.scaleZ = 1 : g.scale3d !== e && (g.scaleX = g.scaleY = g.scaleZ = g.scale3d, delete g.scale3d), g.delay && (g.delay = "after" === d ? g.delay / 1e3 : g.delay), "undefined" == typeof c && (c = "easeInOutQuart"), g.ease = f.functions.convert.easing(c), g
                    },
                    randomProperties: function(a, b) {
                        if (a && a.indexOf("(") !== -1 && a.indexOf(",") !== -1 && a.indexOf(")") !== -1) {
                            var c = a.split("(")[1].split(")")[0].split(","),
                                d = 1;
                            return c[0] = parseFloat(c[0]), c[1] = parseFloat(c[1]), b.indexOf("scale") !== -1 && (d = 100, c[0] *= d, c[1] *= d), Math.floor(Math.random() * (c[1] - c[0] + 1) + c[0]) / d
                        }
                        return a
                    },
                    properties: function(a, b) {
                        if ("string" == typeof a) return f.functions.convert._properties(a, b);
                        if ("object" == typeof a) {
                            for (var c in a) a[c] = f.functions.convert._properties(a[c], b);
                            return a
                        }
                        return a
                    },
                    _properties: function(b, c) {
                        if ("enable" == b || "enabled" == b || "true" == b) return !0;
                        if ("disable" == b || "disabled" == b || "false" == b) return !1;
                        if ("string" == typeof b && b.indexOf(f.defaults.init.lsDataArraySplitChar) !== -1) {
                            for (var d = b.split(f.defaults.init.lsDataArraySplitChar), e = [], g = 0; g < d.length; g++) e[g] = a.isNumeric(d[g]) ? parseFloat(a.trim(d[g])) : a.trim(d[g]);
                            return e
                        }
                        return c ? "" + parseInt(b) == "NaN" ? 0 : parseInt(b) : a.isNumeric(b) ? parseFloat(b) : b
                    },
                    oldProperties: function(b) {
                        var c = {
                            firstLayer: "firstSlide",
                            loops: "cycles",
                            forceLoopNum: "forceCycles",
                            layersContainer: "layersContainerWidth",
                            sublayerContainer: "layersContainerWidth",
                            randomSlideshow: "shuffleSlideshow"
                        };
                        return a.each(c, function(a, c) {
                            a in b && (b[c] = b[a], delete b[a])
                        }), b
                    }
                },
                getSliderClosestParentElementWidthNumericValueOfProperty: function(b) {
                    for (var g, d = c.parents(), e = d.length, h = 100, i = 0; i < e; i++)
                        if (g = window.getComputedStyle(d[i]).getPropertyValue(b), "auto" !== g) {
                            if (g.indexOf("px") !== -1) return f.slider.$parentWithNumericWidthValue = a(d[i]), a(d[i]);
                            g.indexOf("%") !== -1 && (h = h / 100 * parseInt(g), f.slider.$parentWithNumericWidthValuePercent = h)
                        }
                },
                sortArray: function(a, b, c) {
                    var d = [];
                    if ("forward" == c)
                        for (var e = 0; e < a; e++)
                            for (var f = 0; f < b; f++) d.push(e + f * a);
                    else
                        for (var g = a - 1; g > -1; g--)
                            for (var h = b - 1; h > -1; h--) d.push(g + h * a);
                    return d
                },
                shuffleArray: function(a) {
                    for (var c, d, b = a.length; 0 !== b;) d = Math.floor(Math.random() * b), b -= 1, c = a[b], a[b] = a[d], a[d] = c;
                    return a
                },
                countProp: function(a) {
                    var b = 0;
                    for (var c in a) a.hasOwnProperty(c) && ++b;
                    return b
                },
                getURL: function(a) {
                    return a[0].currentSrc ? a[0].currentSrc : a.data("src ") ? a.data("src ") : a.attr("src")
                },
                setStates: function(a, b, d) {
                    if (a && a.state) {
                        var e = f.slideshow.isPaused();
                        if (d) a.state[b] = d;
                        else
                            for (var g in b) a.state[g] = b[g];
                        var h = f.slideshow.isPaused();
                        a == f.slideshow && (f.api.hasEvent("slideshowStateDidChange") && c.triggerHandler("slideshowStateDidChange", f.api.eventData()), h != e && (h ? f.api.hasEvent("slideshowDidPause") && c.triggerHandler("slideshowDidPause", f.api.eventData()) : f.api.hasEvent("slideshowDidResume") && c.triggerHandler("slideshowDidResume", f.api.eventData())))
                    }
                },
                clearTimers: function() {
                    for (var a in f.timeouts) clearTimeout(f.timeouts[a]), delete f.timeouts[a];
                    for (var b in f.intervals) clearInterval(f.intervals[b]), delete f.intervals[b]
                },
                clearTimelines: function() {
                    f.transitions._slideTimeline && (f.transitions._slideTimeline.pause().clear().kill(), delete f.transitions._slideTimeline), f.transitions._forceLayersOut && (f.transitions._forceLayersOut.kill(), delete f.transitions._forceLayersOut), f.transitions._slideTransition && (f.transitions._slideTransition.pause().clear().kill(), delete f.transitions._slideTransition), g.TweenMax.killTweensOf(c.find(".ls-bg, .ls-layer, .ls-wrapper, .ls-curtile, .ls-nexttile").get())
                },
                resetSlideTimelines: function() {
                    f.transitions._slideTimeline && (f.transitions._slideTimeline.pause().progress(0).clear().kill(), delete f.transitions._slideTimeline), f.transitions._forceLayersOut && (f.transitions._forceLayersOut.pause().progress(1).clear().kill(), delete f.transitions._forceLayersOut), c.find(".ls-layer:not(.ls-bg-video)").each(function() {
                        var b = a(this).data(f.defaults.init.dataKey);
                        b.loop._timeline && (b.loop._timeline.stop().clear(), delete b.loop._timeline, g.TweenMax.set(b.elements.$loopWrapper[0], b.reset.loopWrapperOnSlideChange)), g.TweenMax.set(b.elements.$wrapper[0], b.reset.wrapperOnSlideChange)
                    })
                },
                clearEvents: function() {
                    a(window).add("body").add(c).add(c.find("*")).add("." + e).off("." + e + " .debug" + e + " .parallax" + e + " .setter" + e)
                }
            }, f.device = {
                $overflowWrapper: a(a("body").length ? "body" : "html"),
                isMobile: !!navigator.userAgent.match(/(iPhone|iPod|iPad|Android|BlackBerry|BB10|webOS|Windows Phone|mobi|opera mini|nexus 7)/i),
                supportOrientation: !!window.DeviceOrientationEvent,
                scroll: {
                    keys: [32, 33, 34, 35, 36, 37, 38, 39, 40],
                    disable: function() {
                        window.addEventListener && window.addEventListener("DOMMouseScroll", this.preventDefault, !1), window.onwheel = this.preventdefault, window.onmousewheel = document.onmousewheel = this.preventDefault, window.ontouchmove = this.preventDefault, document.onkeydown = this.preventDefaultForScrollKeys
                    },
                    enable: function() {
                        window.removeEventListener && window.removeEventListener("DOMMouseScroll", this.preventDefault, !1), window.onmousewheel = document.onmousewheel = null, window.onwheel = null, window.ontouchmove = null, document.onkeydown = null
                    },
                    preventDefault: function(a) {
                        a = a || window.event, a.preventDefault && a.preventDefault(), a.returnValue = !1
                    },
                    preventDefaultForScrollKeys: function(a) {
                        if (f.device.scroll.keys.indexOf(a.keyCode) !== -1) return f.device.scroll.preventDefault(a), !1
                    }
                },
                fullscreen: {
                    enter: function() {
                        "fullsize" == f.slider.initial.type && "hero" == f.o.fullSizeMode && (f.slider.heroTop = f.slider.offsetTop), f.functions.setStates(f.slider, {
                            inFullscreen: !0
                        }), a("body, html").addClass("ls-fullscreen"), b.requestFullscreen(), c.trigger("mouseleave")
                    },
                    exit: function() {
                        f.functions.setStates(f.slider, {
                            inFullscreen: !1
                        }), f.resize.all(), a("body, html").removeClass("ls-fullscreen")
                    },
                    toggle: function() {
                        f.device.fullscreen.element() ? (f.device.fullscreen.exit(), document.exitFullscreen()) : f.device.fullscreen.enter()
                    },
                    set: function() {
                        f.o.allowFullscreen && (document.fullscreenEnabled || document.webkitFullscreenEnabled || document.mozFullscreenEnabled || document.msFullscreenEnabled) && (b.requestFullscreen = b.requestFullscreen || b.webkitRequestFullscreen || b.mozRequestFullscreen || b.msRequestFullscreen, document.exitFullscreen = document.exitFullscreen || document.webkitExitFullscreen || document.mozCancelFullScreen || document.msExitFullscreen, a(document).on("fullscreenchange." + e + " webkitfullscreenchange." + e + " mozfullscreenchange." + e + " msfullscreenchange." + e, function() {
                            f.device.fullscreen.element() || f.device.fullscreen.exit()
                        }), c.on("dblclick." + e, function() {
                            f.device.fullscreen.toggle()
                        }))
                    },
                    element: function() {
                        return document.fullscreenElement || document.webkitFullscreenElement || document.mozFullscreenElement || document.msFullscreenElement
                    }
                },
                getDimensions: function() {
                    this.width = screen.width, this.height = screen.height, this.viewportWidth = a(window).width(), this.viewportHeight = a(window).height(), this.docWidth = a(document).width(), this.docHeight = a(document).height(), this.winScrollTop = a(window).scrollTop(), this.ratio = this.width / this.height, f.slider.offsetTop = c.offset().top, f.slider.offsetLeft = c.offset().left
                },
                setBasicEvents: function() {
                    var d, b = this;
                    a(window).on("resize.setter" + e, function() {
                        b.viewportWidth = a(window).width(), b.viewportHeight = a(window).height(), b.ratio = b.width / b.height, f.slider.offsetTop = c.offset().top, f.slider.offsetLeft = c.offset().left
                    }), a(window).on("scroll.setter" + e, function() {
                        b.winScrollTop = a(window).scrollTop(), f.slider.offsetTop = c.offset().top, f.slider.offsetLeft = c.offset().left
                    }), a(window).on("touchmove", function(a) {
                        b.winScrollTop = window.pageYOffset, d = a.touches ? a.touches : a.originalEvent.touches, 1 == d.length && (b.touchX = d[0].clientX)
                    })
                }
            }, f.api = {
                hasEvent: function(c, d) {
                    var e = a._data(d || b, "events");
                    return !(!e || !e[c])
                },
                methods: function(a, b, d, g) {
                    if (!f.slider.isBusy())
                        if ("number" == typeof a) a > 0 && a < f.slides.count + 1 && a != f.slides.current.index && f.slideshow.changeTo(a, !0, !0);
                        else switch (a) {
                            case "touchPrev":
                                f.device.touchPrev = !0;
                            case "previousSlide":
                            case "prev":
                                f.navigation.prev();
                                break;
                            case "touchNext":
                                f.device.touchNext = !0;
                            case "nextSlide":
                            case "next":
                                f.navigation.next();
                                break;
                            case "startSlideshow":
                            case "start":
                                f.navigation.start()
                        }
                        switch (a) {
                            case "updateLayerData":
                                b && f.layers.update.data(b, d, g);
                                break;
                            case "redrawSlider":
                            case "redraw":
                                f.resize.all();
                                break;
                            case "replaySlide":
                            case "replay":
                                f.transitions._slideTimeline && (f.transitions._slideTimeline.progress(0), f.transitions._slideTimeline.play());
                                break;
                            case "reverseSlide":
                            case "reverse":
                                f.transitions._slideTimeline && (f.transitions._slideTimeline.reversed() ? f.transitions._slideTimeline.play() : f.transitions._slideTimeline.reverse(), b && (f.transitions.layers.timeline.shouldReplay = !0));
                                break;
                            case "stopSlideshow":
                            case "stop":
                                f.navigation.stop();
                                break;
                            case "pauseSlider":
                            case "pause":
                                f.transitions._slideTimeline && f.transitions._slideTimeline.stop(), f.transitions._slideTransition && f.transitions._slideTransition.stop();
                                break;
                            case "resumeSlider":
                            case "resume":
                                f.transitions._slideTimeline && (f.transitions._slideTimeline.timeScale() < .001 && f.transitions.layers.timeline.resume(), f.transitions._slideTimeline.play()), f.transitions._slideTransition && f.transitions._slideTransition.play();
                                break;
                            case "toggleSlider":
                            case "toggle":
                                f.slider.isPaused ? (c.layerSlider("resume"), f.slider.isPaused = !1) : (c.layerSlider("pause"), f.slider.isPaused = !0);
                                break;
                            case "destroy":
                            case "kill":
                                if (f.slider.state.isLoaded) {
                                    if (f.functions.clearTimers(), f.functions.clearTimelines(), f.functions.clearEvents(), f.layers.$all.removeData(), f.api.hasEvent("sliderDidDestroy") && c.triggerHandler("sliderDidDestroy"), f.slider.state.sholudBeRemoved || b) {
                                        if (f.slider.$hiddenWrapper.remove(), f.gui.timers.slidebar.$containerElement)
                                            for (var h = 0; h < f.gui.timers.slidebar.$containerElement.length; h++) f.gui.timers.slidebar.$containerElement[h] instanceof jQuery && f.gui.timers.slidebar.$containerElement[h].remove();
                                        c.remove(), f.api.hasEvent("sliderDidRemove") && c.triggerHandler("sliderDidRemove")
                                    }
                                    window._layerSlider.removeSlider(e)
                                } else f.functions.setStates(f.slider, {
                                    shouldBeDestroyed: !0,
                                    sholudBeRemoved: !!b && b
                                })
                        }
                },
                eventData: function() {
                    return {
                        data: f,
                        userData: f.o,
                        uid: e,
                        target: b,
                        slider: c,
                        state: f.slider.state,
                        isBusy: f.slider.isBusy(),
                        api: function(a) {
                            c.layerSlider(a)
                        },
                        slides: {
                            first: {
                                index: f.slides.first.index
                            },
                            prev: {
                                index: f.slides.prev.index
                            },
                            current: {
                                index: f.slides.current.index ? f.slides.current.index : f.slides.first.index,
                                layersIn: f.layers.get("current,in"),
                                layersOut: f.layers.get("current,out"),
                                timeline: f.transitions._slideTimeline
                            },
                            next: {
                                index: f.slides.next.index,
                                layersIn: f.layers.get("next,in"),
                                layersOut: f.layers.get("next,out")
                            },
                            count: f.slides.count
                        },
                        slideChangeTimeline: f.transitions._slideTransition,
                        slideshow: {
                            state: f.slideshow.state,
                            sequence: f.slideshow.sequence,
                            direction: f.slideshow.direction,
                            isPaused: f.slideshow.isPaused()
                        },
                        cycles: {
                            max: f.o.cycles,
                            current: f.slideshow.curCycle
                        }
                    }
                }
            }, f.browser = {
                isSafari: !!navigator.userAgent.match(/(iPhone|iPod|iPad|Safari)/i) && !navigator.userAgent.match(/(Opera|Chrome|Edge)/i),
                usesFileProtocol: document.location.href.indexOf("file://") !== -1,
                supports3D: function() {
                    for (var b = a("<div>"), d = !1, e = !1, f = ["perspective", "OPerspective", "msPerspective", "MozPerspective", "WebkitPerspective"], g = ["transformStyle", "OTransformStyle", "msTransformStyle", "MozTransformStyle", "WebkitTransformStyle"], h = f.length - 1; h >= 0; h--) d = d ? d : void 0 !== b[0].style[f[h]];
                    for (var i = g.length - 1; i >= 0; i--) b.css("transform-style", "preserve-3d"), e = e ? e : "preserve-3d" == b[0].style[g[i]];
                    return d && void 0 !== b[0].style[f[4]] && (b.attr("id", "ls-test3d").appendTo(c), d = 3 === b[0].offsetHeight && 9 === b[0].offsetLeft, b.remove()), d && e
                },
                isOld: navigator.userAgent.indexOf("rident/5") !== -1
            }, f.initializedPlugins = {}, f.timeouts = {}, f.intervals = {}, f.debug = {
                options: {}
            }, f.plugin = {
                version: "6.2.0",
                releaseDate: "2017. 03. 21."
            }, f.slider.load()
        }
    }(jQuery);
                                    

Executed Writes (0)



HTTP Transactions (82)


Request Response
                                        
                                            GET / HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive

                                         
                                         185.45.75.168
HTTP/1.1 302 Found
Content-Type: text/html; charset=UTF-8
                                        
Date: Tue, 27 Nov 2018 18:35:37 GMT
Server: Apache
Location: http://sip-global.com/en/
X-Powered-By: PleskLin
Content-Length: 0
Keep-Alive: timeout=5, max=100
Connection: Keep-Alive


--- Additional Info ---
                                        
                                            GET /en/ HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: text/html; charset=UTF-8
                                        
Date: Tue, 27 Nov 2018 18:35:38 GMT
Server: Apache
X-Pingback: http://sip-global.com/xmlrpc.php
Link: <http://sip-global.com/wp-json/>; rel="https://api.w.org/", <http://sip-global.com/>; rel=shortlink
Set-Cookie: pll_language=en; expires=Wed, 27-Nov-2019 18:35:38 GMT; Max-Age=31536000; path=/
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 21877
Keep-Alive: timeout=5, max=99
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   21877
Md5:    dde7ee1af148ebbe51c3a1bc2bed787d
Sha1:   321330fd5b05282c24d323ab86385f0a5c7f6a1d
Sha256: 6b03d0237f14c79e6a406cd1a7c5574caf0f267279983afaff7467609f2e6073
                                        
                                            GET /wp-includes/js/wp-emoji-release.min.js?ver=4.8.7 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Tue, 27 Nov 2018 18:35:38 GMT
Server: Apache
Last-Modified: Wed, 20 Sep 2017 07:36:16 GMT
Etag: "2e8b-5599a07e77c00-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 4323
Keep-Alive: timeout=5, max=98
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   4323
Md5:    d6527c3d0b14313cf8aa786fe5c9bec1
Sha1:   7bc55116ab3e3acff1d85b0c03d69f2f5ca0d1c1
Sha256: ebb3cd48a02aafdfef89afd89e9a9119a89feec1e73182e5f34a6b4f28c12dff
                                        
                                            GET /css?family=Open+Sans%3A1%2C300%2C400%2C400italic%2C700&ver=4.8.7 HTTP/1.1 
Host: fonts.googleapis.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/css,*/*;q=0.1
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/

                                         
                                         172.217.21.170
HTTP/1.1 200 OK
Content-Type: text/css; charset=utf-8
                                        
Access-Control-Allow-Origin: *
Timing-Allow-Origin: *
Expires: Tue, 27 Nov 2018 18:35:36 GMT
Date: Tue, 27 Nov 2018 18:35:36 GMT
Cache-Control: private, max-age=86400
Content-Encoding: gzip
Transfer-Encoding: chunked
Server: ESF
X-XSS-Protection: 1; mode=block
X-Frame-Options: SAMEORIGIN


--- Additional Info ---
Magic:  gzip compressed data, max compression
Size:   284
Md5:    40fa6a5a3d0e0ed67e31b3c800cc06d2
Sha1:   41f1c977916901ac6fa32966c6e59837ea48d3ca
Sha256: cbe56a848c2e25d21a71b88786eb0aff011fd7f6d84383fa9d10198edb3aad15
                                        
                                            GET /css?family=Roboto%3A1%2C300%2C400%2C400italic%2C700&ver=4.8.7 HTTP/1.1 
Host: fonts.googleapis.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/css,*/*;q=0.1
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/

                                         
                                         172.217.21.170
HTTP/1.1 200 OK
Content-Type: text/css; charset=utf-8
                                        
Access-Control-Allow-Origin: *
Timing-Allow-Origin: *
Expires: Tue, 27 Nov 2018 18:35:36 GMT
Date: Tue, 27 Nov 2018 18:35:36 GMT
Cache-Control: private, max-age=86400
Content-Encoding: gzip
Transfer-Encoding: chunked
Server: ESF
X-XSS-Protection: 1; mode=block
X-Frame-Options: SAMEORIGIN


--- Additional Info ---
Magic:  gzip compressed data, max compression
Size:   272
Md5:    1b142fefb3e35034773e3d3febb85b85
Sha1:   9a15c8a6331d99519d0dd1e05529664f97e6b228
Sha256: 52529a323a55ba0868d4482bbec7675f4b191a8f73a3c781e08fe85a3f71f7e2
                                        
                                            GET /wp-content/plugins/contact-form-7/includes/css/styles.css?ver=4.9.1 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/css,*/*;q=0.1
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Date: Tue, 27 Nov 2018 18:35:38 GMT
Server: Apache
Last-Modified: Thu, 30 Nov 2017 16:57:25 GMT
Etag: "646-55f3625774740-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 634
Keep-Alive: timeout=5, max=100
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   634
Md5:    61e8277a5af14469cf9aecd720125e6e
Sha1:   7ebab102eee5c904bcf9155f23cd80dec090f83e
Sha256: c86896669cf4a3f0fcee46df672f70f0cdd9fcb00b5b8dbc4f08254a7c5e798b
                                        
                                            GET /wp-content/plugins/LayerSlider/static/layerslider/css/layerslider.css?ver=6.2.0 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/css,*/*;q=0.1
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Date: Tue, 27 Nov 2018 18:35:38 GMT
Server: Apache
Last-Modified: Thu, 15 Jun 2017 06:46:46 GMT
Etag: "4fcd-551fa08458180-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 3781
Keep-Alive: timeout=5, max=100
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   3781
Md5:    3b48ef58377ba33930498f1086d53247
Sha1:   a5921bcfff9b0717272567e24aa231ded60b9503
Sha256: 18e4a8052e95e69bf6a8e842ad362f8cd2ed3aca72f3d8ab9144da8529b2dd69
                                        
                                            GET /wp-content/plugins/revslider/public/assets/css/settings.css?ver=5.4.1 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/css,*/*;q=0.1
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Date: Tue, 27 Nov 2018 18:35:38 GMT
Server: Apache
Last-Modified: Thu, 15 Jun 2017 06:46:42 GMT
Etag: "745d-551fa08087880-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 7067
Keep-Alive: timeout=5, max=100
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   7067
Md5:    1aa1d87a07454652067ad905f6d460b6
Sha1:   9f67fb5fb2dff47e57d1b4243ee05f58c304fc39
Sha256: 3e9cfcec7a6f26a0599788c5f0c885db78c692bc7e796e8655f1a1dbdda3a992
                                        
                                            GET /wp-content/themes/betheme/css/base.css?ver=17.5 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/css,*/*;q=0.1
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Date: Tue, 27 Nov 2018 18:35:38 GMT
Server: Apache
Last-Modified: Thu, 06 Apr 2017 11:26:31 GMT
Etag: "cb49-54c7dc7d807c0-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 10933
Keep-Alive: timeout=5, max=100
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   10933
Md5:    a93eeed903c73b72ce4ae6b4f19f1d57
Sha1:   5dd562e20aba53fcf67b8e73cb216d088e9cdbb6
Sha256: db72ba45dc0bbdc83de41988443321ac24b0b5bdfb8f7b39ef24fc5b3331ec77
                                        
                                            GET /wp-content/themes/betheme/css/shortcodes.css?ver=17.5 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/css,*/*;q=0.1
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Date: Tue, 27 Nov 2018 18:35:38 GMT
Server: Apache
Last-Modified: Thu, 06 Apr 2017 11:26:31 GMT
Etag: "21edd-54c7dc7d807c0-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 22334
Keep-Alive: timeout=5, max=97
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   22334
Md5:    d41a01944629a3f1c70830dcfa2bd4b1
Sha1:   25325e84009ad75bf5e5f40e566831f05a962859
Sha256: 886f4e5f769b1e809b4a487ec38bac28f4173ed59a103a882b31af4c328e63aa
                                        
                                            GET /wp-content/themes/betheme/assets/ui/jquery.ui.all.css?ver=17.5 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/css,*/*;q=0.1
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Date: Tue, 27 Nov 2018 18:35:38 GMT
Server: Apache
Last-Modified: Thu, 06 Apr 2017 11:26:43 GMT
Etag: "4c90-54c7dc88f22c0-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 3471
Keep-Alive: timeout=5, max=99
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   3471
Md5:    ca922635a1e4badf7367f02146532f30
Sha1:   28e3724f0c541211b8130a6e0e86bbbf36b9f911
Sha256: b4bf38b2134f0d12e6c18ba78b4b457197a5869267ac192fcf0daa8c35d5061a
                                        
                                            GET /wp-content/themes/betheme/assets/animations/animations.min.css?ver=17.5 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/css,*/*;q=0.1
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Date: Tue, 27 Nov 2018 18:35:38 GMT
Server: Apache
Last-Modified: Thu, 06 Apr 2017 11:26:42 GMT
Etag: "e48c-54c7dc87fe080-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 5418
Keep-Alive: timeout=5, max=99
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   5418
Md5:    047b182d86f7800f775fc5e0e6c85d1f
Sha1:   cf5f3e02837f526e2a907987d7cdefee8d078ab4
Sha256: 50722c5b1c407a8443b02aff3a56c6e6f4c3326e12824548afcf644ce89fbc26
                                        
                                            GET /wp-content/themes/betheme/assets/prettyPhoto/prettyPhoto.css?ver=17.5 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/css,*/*;q=0.1
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Date: Tue, 27 Nov 2018 18:35:38 GMT
Server: Apache
Last-Modified: Thu, 06 Apr 2017 11:26:43 GMT
Etag: "47d4-54c7dc88f22c0-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 2724
Keep-Alive: timeout=5, max=99
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   2724
Md5:    09773704c9224b9466fa2bb3d62ad9a5
Sha1:   81c998311e8e3ead5880e869d21f7536b18c43d9
Sha256: 8e2b5d9f26f7da6f53565b208f4acf21268d9eaabc65e26aa81449253cf63084
                                        
                                            GET /wp-content/themes/betheme/assets/jplayer/css/jplayer.blue.monday.css?ver=17.5 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/css,*/*;q=0.1
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Date: Tue, 27 Nov 2018 18:35:38 GMT
Server: Apache
Last-Modified: Thu, 06 Apr 2017 11:26:48 GMT
Etag: "27a1-54c7dc8db6e00-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 2146
Keep-Alive: timeout=5, max=99
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   2146
Md5:    57af2bb1e4db675d0af96ff80b2c4c1c
Sha1:   cef33b72fbcece63f3f42741d94758642e153aaf
Sha256: e28401aa4628d1ce9785ae46ae920f25d0cd8d3e50874c5bffc11d403fe807d0
                                        
                                            GET /wp-content/themes/betheme/css/layout.css?ver=17.5 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/css,*/*;q=0.1
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Date: Tue, 27 Nov 2018 18:35:38 GMT
Server: Apache
Last-Modified: Wed, 20 Dec 2017 21:16:23 GMT
Etag: "1bd95-560cc186dd7c0-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 19292
Keep-Alive: timeout=5, max=100
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   19292
Md5:    12b17fdccd10bb9f9ccb0932e1548290
Sha1:   6a97d2fd3a8f0574caa035be4260b2f13cb128b4
Sha256: e8186d74e678cd2979241c5424b6b3d982e646d0fad378b1e6bcc3f2a2d1b316
                                        
                                            GET /wp-content/themes/betheme/css/responsive.css?ver=17.5 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/css,*/*;q=0.1
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Date: Tue, 27 Nov 2018 18:35:38 GMT
Server: Apache
Last-Modified: Thu, 06 Apr 2017 11:26:31 GMT
Etag: "d60c-54c7dc7d807c0-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 9746
Keep-Alive: timeout=5, max=96
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   9746
Md5:    9a46d88ccaa5ea6978605a37753e990d
Sha1:   0ea7fabb537e9af9a59f2da8de4ed130722e4248
Sha256: 090c7e1e12cf881a2b9db4078646768bf4f8d83c3e675643da639d0485b0579a
                                        
                                            GET /wp-content/themes/betheme-child/style.css?ver=17.5 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/css,*/*;q=0.1
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Date: Tue, 27 Nov 2018 18:35:38 GMT
Server: Apache
Last-Modified: Thu, 06 Apr 2017 11:28:18 GMT
Etag: "15a-54c7dce38b880-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 202
Keep-Alive: timeout=5, max=98
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   202
Md5:    539bf3f23b97f3e2e6265539a5867430
Sha1:   98a594e2fe7536b4fb4df7ba7ac4b61cdea39e17
Sha256: 2e754790496b7dac9adaf2b2320cafcafe0a21d46f296d357ef2de46ce7acac2
                                        
                                            GET /wp-includes/js/jquery/jquery-migrate.min.js?ver=1.4.1 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Tue, 27 Nov 2018 18:35:38 GMT
Server: Apache
Last-Modified: Thu, 06 Apr 2017 11:09:31 GMT
Etag: "2748-54c7d8b0c10c0-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 4014
Keep-Alive: timeout=5, max=98
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   4014
Md5:    a6c81e2f02bd04160d2de88c4e8f3559
Sha1:   e3f3c91427d785820ca97dabe738f01faf041f36
Sha256: b734d83af5da0eb627e04d3e62ce652b9eb7de19667a1b91da6b93f0ea5d7ffe
                                        
                                            GET /wp-content/plugins/LayerSlider/static/layerslider/js/layerslider.transitions.js?ver=6.2.0 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Tue, 27 Nov 2018 18:35:38 GMT
Server: Apache
Last-Modified: Thu, 15 Jun 2017 06:46:46 GMT
Etag: "5d17-551fa08458180-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 3396
Keep-Alive: timeout=5, max=95
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   3396
Md5:    eb670015b0b1f37defff4ffcf890f043
Sha1:   efbc16d930be1673c69a33063f6e0ce1c1938d5a
Sha256: 5b14e2fb3079ca42ea5d465dfd942a4944c4e0df08d4d0e14abc0f9e90b362da
                                        
                                            GET /css?family=Roboto:400%2C500 HTTP/1.1 
Host: fonts.googleapis.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/css,*/*;q=0.1
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/

                                         
                                         172.217.21.170
HTTP/1.1 200 OK
Content-Type: text/css; charset=utf-8
                                        
Access-Control-Allow-Origin: *
Timing-Allow-Origin: *
Expires: Tue, 27 Nov 2018 18:35:37 GMT
Date: Tue, 27 Nov 2018 18:35:37 GMT
Cache-Control: private, max-age=86400
Content-Encoding: gzip
Transfer-Encoding: chunked
Server: ESF
X-XSS-Protection: 1; mode=block
X-Frame-Options: SAMEORIGIN


--- Additional Info ---
Magic:  gzip compressed data, max compression
Size:   222
Md5:    58a1cc3163440599b03a104b0e49391a
Sha1:   4de7bee580046976b037d6a86354c7e7b8343830
Sha256: 95d728ca2fc96f15a6832ef85b0e7141b74e4d513fe23c77277c1838239c714a
                                        
                                            GET /wp-includes/js/jquery/jquery.js?ver=1.12.4 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Tue, 27 Nov 2018 18:35:38 GMT
Server: Apache
Last-Modified: Thu, 06 Apr 2017 11:09:32 GMT
Etag: "17ba0-54c7d8b1b5300-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 33766
Keep-Alive: timeout=5, max=98
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   33766
Md5:    d417f4d673009b01654915bbf1f4f872
Sha1:   f432ea8e89e5f4ef50e506019899e539a068f415
Sha256: 24560d81ded58e8befabf32ff51f5b6ae6f21eead0a5f87c255e3b47b988d1cc
                                        
                                            GET /wp-content/plugins/LayerSlider/static/layerslider/js/greensock.js?ver=1.19.0 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Tue, 27 Nov 2018 18:35:38 GMT
Server: Apache
Last-Modified: Thu, 15 Jun 2017 06:46:46 GMT
Etag: "1cc0a-551fa08458180-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 39585
Keep-Alive: timeout=5, max=98
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   39585
Md5:    7f0e2013dbc431f2f3bcf2d93f8fe047
Sha1:   5cd77ba1d8daca6b768d8ed4c7cbba445d592f25
Sha256: 48a303a5341716201148a5965e9bc1691b13c3dc04e80fc9340332085fecafdd
                                        
                                            GET /wp-content/plugins/revslider/public/assets/js/jquery.themepunch.revolution.min.js?ver=5.4.1 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Tue, 27 Nov 2018 18:35:38 GMT
Server: Apache
Last-Modified: Thu, 15 Jun 2017 06:46:42 GMT
Etag: "f75b-551fa08087880-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 17555
Keep-Alive: timeout=5, max=97
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   17555
Md5:    dad814e2bea0c0b9d8bcd1dbae0b3764
Sha1:   ec0bf4e04e10eca972e0a27e1168286ca0fd75d1
Sha256: 48e211b5433922ae10a4c3b385e494955007ed49df4f00e827cd81c1d5228356
                                        
                                            GET /wp-content/plugins/LayerSlider/static/layerslider/js/layerslider.kreaturamedia.jquery.js?ver=6.2.0 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Tue, 27 Nov 2018 18:35:38 GMT
Server: Apache
Last-Modified: Thu, 15 Jun 2017 06:46:46 GMT
Etag: "1b0d3-551fa08458180-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 42348
Keep-Alive: timeout=5, max=99
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   42348
Md5:    c5d01997233ab32045f1e4c429735910
Sha1:   fec61039d2981fb487fd28a414cc49afba58c975
Sha256: 47eb5dfc96f847ba2fc4f0eba885d81f8f51ddb9e905da357764b7f8cfd574be
                                        
                                            GET /wp-content/plugins/revslider/public/assets/js/jquery.themepunch.tools.min.js?ver=5.4.1 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Tue, 27 Nov 2018 18:35:38 GMT
Server: Apache
Last-Modified: Thu, 15 Jun 2017 06:46:42 GMT
Etag: "1a40e-551fa08087880-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 37359
Keep-Alive: timeout=5, max=97
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   37359
Md5:    c6adabe91d8b35fc61aebe979b6af81b
Sha1:   87f0d05b3899cd534287c6b97975991efdc73139
Sha256: 568a1958f3d17faaaaf84bb1ab5289f6899caeb9708c92b6dabd99e5dbf4ade9
                                        
                                            GET /wp-content/plugins/contact-form-7/includes/js/scripts.js?ver=4.9.1 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Tue, 27 Nov 2018 18:35:39 GMT
Server: Apache
Last-Modified: Thu, 30 Nov 2017 16:57:25 GMT
Etag: "3654-55f3625774740-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 3889
Keep-Alive: timeout=5, max=97
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   3889
Md5:    154e9e9c316b40a232b7c3dc4c5b0ed6
Sha1:   e85cd7abb9e590dfc45dd386d9369634a62f2af8
Sha256: d27fcd16887e81d162e71941ac586293d4abdc7d78ffa55ba2893f91d3311766
                                        
                                            GET /wp-includes/js/jquery/ui/widget.min.js?ver=1.11.4 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Tue, 27 Nov 2018 18:35:39 GMT
Server: Apache
Last-Modified: Thu, 06 Apr 2017 11:09:38 GMT
Etag: "1afc-54c7d8b76e080-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 2599
Keep-Alive: timeout=5, max=98
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   2599
Md5:    24ee35ca0d4dd9a145c9410488b1c437
Sha1:   982c556c82123a94f78e806a5e468c94c711193e
Sha256: ca41e151a9594fb5ee401818ac96cc6db69b353e2940478f22ab48ce78a5d3c9
                                        
                                            GET /wp-includes/js/jquery/ui/core.min.js?ver=1.11.4 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Tue, 27 Nov 2018 18:35:39 GMT
Server: Apache
Last-Modified: Thu, 06 Apr 2017 11:09:37 GMT
Etag: "fa0-54c7d8b679e40-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 1821
Keep-Alive: timeout=5, max=96
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   1821
Md5:    4664a831e60a807962a0341122693831
Sha1:   0c582fa939884d543af617c2bad977157f8c319b
Sha256: f1320f1c4d030cd930d721d93ea112dc789295f06afc8a3381c922a92b077f0d
                                        
                                            GET /wp-content/plugins/revslider/public/assets/fonts/font-awesome/css/font-awesome.css HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/css,*/*;q=0.1
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Date: Tue, 27 Nov 2018 18:35:39 GMT
Server: Apache
Last-Modified: Thu, 15 Jun 2017 06:46:42 GMT
Etag: "a250-551fa08087880-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 7605
Keep-Alive: timeout=5, max=97
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   7605
Md5:    2397e61f4f750bf656f4849f08eae62d
Sha1:   d35eab44e2b7cff22512b446ac575b40c9480373
Sha256: cc5102652b1728bf09af4d37d7b0650a637dde69247085456aa97de980268d47
                                        
                                            GET /wp-content/uploads/2017/07/logoweb2.png HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: image/png,image/*;q=0.8,*/*;q=0.5
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: image/png
                                        
Date: Tue, 27 Nov 2018 18:35:38 GMT
Server: Apache
Last-Modified: Thu, 27 Jul 2017 06:43:50 GMT
Etag: "1736e-55546e31db580"
Accept-Ranges: bytes
Content-Length: 95086
X-Powered-By: PleskLin
Keep-Alive: timeout=5, max=94
Connection: Keep-Alive


--- Additional Info ---
Magic:  PNG image, 2249 x 1126, 8-bit/color RGBA, non-interlaced
Size:   95086
Md5:    f15d8a9644cee8f90519872ac4082c0b
Sha1:   5bcb01593fccb46ef4da1fd29b117e42e783eaa0
Sha256: 2b5b7e090abc3f8038c83d9163f0686e5edcf7350f0c68c6e51f2f68cf778070
                                        
                                            GET /wp-includes/js/jquery/ui/mouse.min.js?ver=1.11.4 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Tue, 27 Nov 2018 18:35:39 GMT
Server: Apache
Last-Modified: Thu, 06 Apr 2017 11:09:38 GMT
Etag: "c4c-54c7d8b76e080-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 1021
Keep-Alive: timeout=5, max=96
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   1021
Md5:    4a1d87217e0005156a94169a73171692
Sha1:   2d1200d355a9633ee5ee756ba1eff5f416efa091
Sha256: 1a1be99e7b7a21dc1bdb8028bd3efdcda29bf8fd61768e3e72fe88435f5a6b0a
                                        
                                            GET /wp-includes/js/jquery/ui/sortable.min.js?ver=1.11.4 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Tue, 27 Nov 2018 18:35:39 GMT
Server: Apache
Last-Modified: Thu, 06 Apr 2017 11:09:38 GMT
Etag: "6143-54c7d8b76e080-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 6550
Keep-Alive: timeout=5, max=96
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   6550
Md5:    2d0f27a52e5960a5e0af7ac654195351
Sha1:   6d5490519f8a5cfbd5475adf766e786ea8e4cae8
Sha256: bcb3c13a2fadcf12b3a5a6fb04c0bc375c0fb2dacd8f98d42c3d41c7c2c91ecf
                                        
                                            GET /wp-content/themes/betheme/js/plugins.js?ver=17.5 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Tue, 27 Nov 2018 18:35:39 GMT
Server: Apache
Last-Modified: Thu, 06 Apr 2017 11:26:35 GMT
Etag: "3014a-54c7dc81510c0-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 52535
Keep-Alive: timeout=5, max=96
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   52535
Md5:    d3323b204a0c036601c58575ce2dc774
Sha1:   87067ee1033077c3acb1f0a046ba7a3caec3ea41
Sha256: 4fccc76362797995ae99849ad65e51dface4e9274f630a8f48806a579e084ef5
                                        
                                            GET /wp-includes/js/jquery/ui/accordion.min.js?ver=1.11.4 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Tue, 27 Nov 2018 18:35:39 GMT
Server: Apache
Last-Modified: Thu, 06 Apr 2017 11:09:37 GMT
Etag: "2188-54c7d8b679e40-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 2707
Keep-Alive: timeout=5, max=95
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   2707
Md5:    487c49117b56742c222364c662b35650
Sha1:   66184692354c96d0bfd22dd0291d235b5b5ca89c
Sha256: b88beebf89515edfc9c2e509eb3c902dad05205d102566ed4a543b9cecf81849
                                        
                                            GET /wp-includes/js/jquery/ui/tabs.min.js?ver=1.11.4 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Tue, 27 Nov 2018 18:35:39 GMT
Server: Apache
Last-Modified: Thu, 06 Apr 2017 11:09:38 GMT
Etag: "2f4e-54c7d8b76e080-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 3889
Keep-Alive: timeout=5, max=97
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   3889
Md5:    016344e82da329adfd24d5a148a9f8f3
Sha1:   6ed93d2e32cfe59ccee9687f1dc1c973084dc73f
Sha256: 32dc14ed8c3233e678c47b93b57e1fc159a0f19b0735bdf4af31ade5739e59ab
                                        
                                            GET /wp-content/themes/betheme/js/menu.js?ver=17.5 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Tue, 27 Nov 2018 18:35:39 GMT
Server: Apache
Last-Modified: Thu, 06 Apr 2017 11:26:34 GMT
Etag: "991-54c7dc805ce80-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 860
Keep-Alive: timeout=5, max=93
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   860
Md5:    49d8624d80cd6f1e6f8d78f62f3c395a
Sha1:   a8c9c1d25e8c8ed650a26be3e101a0aebe7d079d
Sha256: 5c4c9950891ea9f7e5eea7d2f22b13f3756dfc412434f9277596156f3d6fc738
                                        
                                            GET /wp-includes/js/comment-reply.min.js?ver=4.8.7 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Tue, 27 Nov 2018 18:35:39 GMT
Server: Apache
Last-Modified: Thu, 06 Apr 2017 11:09:20 GMT
Etag: "436-54c7d8a643800-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 589
Keep-Alive: timeout=5, max=96
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   589
Md5:    758a8d85f5e231ed27925940ff07a66e
Sha1:   d2474fc7829e253cc08a43bec5a60f07bd925d12
Sha256: f2233a526acca18657a60b6071f85fcdd69273253fb32632baed2bad08212436
                                        
                                            GET /wp-content/themes/betheme/assets/animations/animations.min.js?ver=17.5 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Tue, 27 Nov 2018 18:35:39 GMT
Server: Apache
Last-Modified: Thu, 06 Apr 2017 11:26:42 GMT
Etag: "768-54c7dc87fe080-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 624
Keep-Alive: timeout=5, max=95
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   624
Md5:    6a4f40992beb0747733487869e5d8e30
Sha1:   2660fdfd91b7e6d8d27d4ae4b766a20b9438afc4
Sha256: 2060dfbdd2c79365c37ff84e24d2e64b8eb4b7351549886a24b11d6b4c0ca969
                                        
                                            GET /wp-content/themes/betheme/assets/jplayer/jplayer.min.js?ver=17.5 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Tue, 27 Nov 2018 18:35:39 GMT
Server: Apache
Last-Modified: Thu, 06 Apr 2017 11:26:43 GMT
Etag: "cdde-54c7dc88f22c0-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 12737
Keep-Alive: timeout=5, max=95
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   12737
Md5:    726f18db87e59c072d25f118a66361ff
Sha1:   97b8595a76e4873db8024b5f92df95235fc524a7
Sha256: 35a5b003bcbcec3a9b477ebd1e2c9f5181e8287c0cf2d86dd235a75b1e6182ae
                                        
                                            GET /wp-content/themes/betheme/js/scripts.js?ver=17.5 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Tue, 27 Nov 2018 18:35:39 GMT
Server: Apache
Last-Modified: Thu, 06 Apr 2017 11:26:35 GMT
Etag: "10b15-54c7dc81510c0-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 12870
Keep-Alive: timeout=5, max=94
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   12870
Md5:    89a894dc1253f6ada950471c95be88a8
Sha1:   41eb1979a9048526f5c2d761f5fe5a2254fa92cf
Sha256: 1163dec730224279e76e6895e9d10656e75e4f102500ace634651efb929ca427
                                        
                                            GET /wp-content/themes/betheme/js/parallax/translate3d.js?ver=17.5 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Tue, 27 Nov 2018 18:35:39 GMT
Server: Apache
Last-Modified: Thu, 06 Apr 2017 11:26:46 GMT
Etag: "1a30-54c7dc8bce980-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 1659
Keep-Alive: timeout=5, max=95
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   1659
Md5:    4cf6fced31a51a9ff3ae09064dc36354
Sha1:   6c694e531c6736538ae923d4bb8f1e2fd5613f27
Sha256: 51d693f3b8aba8aeecd6d20143637db7bb0afb25713157109980e85b172fa024
                                        
                                            GET /wp-includes/js/wp-embed.min.js?ver=4.8.7 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Tue, 27 Nov 2018 18:35:39 GMT
Server: Apache
Last-Modified: Thu, 06 Apr 2017 11:09:24 GMT
Etag: "576-54c7d8aa14100-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
X-Powered-By: PleskLin
Content-Length: 751
Keep-Alive: timeout=5, max=92
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   751
Md5:    7542039ce963ffd18ad4fb7be13bd2be
Sha1:   8385e433e8e65739fc27b6bd16b1a7ae71b11084
Sha256: a70bca1336a4ac7592ce631cbb22c9ebb01d60461d221ac7a46f91a4ccfd1255
                                        
                                            GET /wp-content/uploads/2017/06/3g.png HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: image/png,image/*;q=0.8,*/*;q=0.5
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: image/png
                                        
Date: Tue, 27 Nov 2018 18:35:39 GMT
Server: Apache
Last-Modified: Fri, 16 Jun 2017 09:48:28 GMT
Etag: "63a3-55210afec3300"
Accept-Ranges: bytes
Content-Length: 25507
X-Powered-By: PleskLin
Keep-Alive: timeout=5, max=94
Connection: Keep-Alive


--- Additional Info ---
Magic:  PNG image, 118 x 142, 8-bit/color RGBA, non-interlaced
Size:   25507
Md5:    edb3f9062b692cfe47fa7b1d3f05932f
Sha1:   cc5ce76390483004ca6c981de8f2b5be17246235
Sha256: c92a272b6e0faf90aef907b7dea08afe6799d71582d7c457d7c62cea65753e41
                                        
                                            GET /wp-content/uploads/2017/06/12g.png HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: image/png,image/*;q=0.8,*/*;q=0.5
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: image/png
                                        
Date: Tue, 27 Nov 2018 18:35:39 GMT
Server: Apache
Last-Modified: Wed, 21 Jun 2017 11:25:30 GMT
Etag: "4ec5-55276a025be80"
Accept-Ranges: bytes
Content-Length: 20165
X-Powered-By: PleskLin
Keep-Alive: timeout=5, max=94
Connection: Keep-Alive


--- Additional Info ---
Magic:  PNG image, 118 x 142, 8-bit/color RGBA, non-interlaced
Size:   20165
Md5:    14b554809b5449d4c7495bb81ee15289
Sha1:   a23a9acf0afe55fcb52f0d4887f3f9fc55d02961
Sha256: 66f68136e643cd771b324d769c1ef2af925438eaa7a32319797da426fd1ad161
                                        
                                            GET /wp-content/uploads/2017/06/2g.png HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: image/png,image/*;q=0.8,*/*;q=0.5
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: image/png
                                        
Date: Tue, 27 Nov 2018 18:35:39 GMT
Server: Apache
Last-Modified: Fri, 16 Jun 2017 09:48:26 GMT
Etag: "4869-55210afcdae80"
Accept-Ranges: bytes
Content-Length: 18537
X-Powered-By: PleskLin
Keep-Alive: timeout=5, max=93
Connection: Keep-Alive


--- Additional Info ---
Magic:  PNG image, 118 x 142, 8-bit/color RGBA, non-interlaced
Size:   18537
Md5:    485d410a7f099361bad8b14ddfe4f887
Sha1:   d81309064dcb9ee7ea1f7bd3de4ad90585c56112
Sha256: e05f41ebcd4bb5d496e5b79f24556885d51b05ecf1cee6b7f914729877e702dc
                                        
                                            GET /wp-content/uploads/2017/09/Viata-cu-scop-este-mai-sanatoasa-decat-viata-cu-satisfactii2-730x486.jpg HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: image/png,image/*;q=0.8,*/*;q=0.5
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: image/jpeg
                                        
Date: Tue, 27 Nov 2018 18:35:39 GMT
Server: Apache
Last-Modified: Thu, 07 Sep 2017 16:18:47 GMT
Etag: "ba44-5589bd0a1e7c0"
Accept-Ranges: bytes
Content-Length: 47684
X-Powered-By: PleskLin
Keep-Alive: timeout=5, max=95
Connection: Keep-Alive


--- Additional Info ---
Magic:  JPEG image data, JFIF standard 1.01
Size:   47684
Md5:    17fcedeea495edc7f94df89522f60eaa
Sha1:   a647e23fc7d5fadb1b7647b9a32aaca8a7e22c2d
Sha256: bfb2c87dbb531855686c4d339a91dd4ab7114b17c3b53ac0ea7bd468d246fe6d
                                        
                                            GET /wp-content/uploads/2017/06/favicon-sip.png HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: image/png,image/*;q=0.8,*/*;q=0.5
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: image/png
                                        
Date: Tue, 27 Nov 2018 18:35:39 GMT
Server: Apache
Last-Modified: Thu, 15 Jun 2017 07:26:59 GMT
Etag: "4b02-551fa9818f6c0"
Accept-Ranges: bytes
Content-Length: 19202
X-Powered-By: PleskLin
Keep-Alive: timeout=5, max=94
Connection: Keep-Alive


--- Additional Info ---
Magic:  PNG image, 50 x 61, 8-bit/color RGBA, non-interlaced
Size:   19202
Md5:    4c78a77c839973b5248ab2d03cc3a3ef
Sha1:   f8d382648d35ae7c4cbb81327ee856f9bbdc4ebb
Sha256: 59a31aacc00134e85b510359d0ef6a16bd9a77d051e99ec3be8adf4ac30b53e9
                                        
                                            POST /GTSGIAG3 HTTP/1.1 
Host: ocsp.pki.goog
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Content-Length: 107
Content-Type: application/ocsp-request

                                         
                                         172.217.22.174
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Date: Tue, 27 Nov 2018 18:35:38 GMT
Cache-Control: public, max-age=86400
Server: ocsp_responder
Content-Length: 463
X-XSS-Protection: 1; mode=block
X-Frame-Options: SAMEORIGIN


--- Additional Info ---
Magic:  data
Size:   463
Md5:    4a2976d8ce2aee5fc0cc9958c419c7aa
Sha1:   cdf74e18e293bac0800197a03b301974377f263d
Sha256: ebabc1d44ce2abf42092e5d2c1139baa99a46187ef5afc3b5e569746444ee76e
                                        
                                            GET /wp-content/uploads/2015/01/1.jpg HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: image/png,image/*;q=0.8,*/*;q=0.5
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: image/jpeg
                                        
Date: Tue, 27 Nov 2018 18:35:39 GMT
Server: Apache
Last-Modified: Thu, 21 Sep 2017 09:54:52 GMT
Etag: "2821c-559b0156af300"
Accept-Ranges: bytes
Content-Length: 164380
X-Powered-By: PleskLin
Keep-Alive: timeout=5, max=94
Connection: Keep-Alive


--- Additional Info ---
Magic:  JPEG image data, EXIF standard
Size:   164380
Md5:    f461a9973a71d16dd2a3a4f957ec23b5
Sha1:   6d440c003edba9890067fd0a8a716c52f5321822
Sha256: e84602421cb9748dc6222b915e5ba6ff74d5764b7c9dbd193c068ba087e0672f
                                        
                                            GET /wp-content/uploads/2015/01/sport.jpg HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: image/png,image/*;q=0.8,*/*;q=0.5
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: image/jpeg
                                        
Date: Tue, 27 Nov 2018 18:35:39 GMT
Server: Apache
Last-Modified: Fri, 16 Jun 2017 09:20:11 GMT
Etag: "3a40f-552104ac608c0"
Accept-Ranges: bytes
Content-Length: 238607
X-Powered-By: PleskLin
Keep-Alive: timeout=5, max=92
Connection: Keep-Alive


--- Additional Info ---
Magic:  JPEG image data, EXIF standard
Size:   238607
Md5:    c8b8df8b0a4127188deb7d903ad08b51
Sha1:   c4a94d29e7b18048bcbdd871ee4957bf0fdb013e
Sha256: c545ec2ff6bbe720b830dbdfd9ebbc457c436ca3b48d6134de949f32584b7bdf
                                        
                                            GET /s/roboto/v18/KFOmCnqEu92Fr1Mu4mxM.woff HTTP/1.1 
Host: fonts.gstatic.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://fonts.googleapis.com/css?family=Roboto%3A1%2C300%2C400%2C400italic%2C700&ver=4.8.7
Origin: http://sip-global.com

                                         
                                         172.217.21.131
HTTP/1.1 200 OK
Content-Type: font/woff
                                        
Accept-Ranges: bytes
Access-Control-Allow-Origin: *
Timing-Allow-Origin: *
Content-Length: 19824
Date: Mon, 12 Nov 2018 22:37:02 GMT
Expires: Tue, 12 Nov 2019 22:37:02 GMT
Last-Modified: Mon, 16 Oct 2017 17:32:56 GMT
X-Content-Type-Options: nosniff
Server: sffe
X-XSS-Protection: 1; mode=block
Cache-Control: public, max-age=31536000
Age: 1281538


--- Additional Info ---
Magic:  data
Size:   19824
Md5:    bafb105baeb22d965c70fe52ba6b49d9
Sha1:   934014cc9bbe5883542be756b3146c05844b254f
Sha256: 1570f866bf6eae82041e407280894a86ad2b8b275e01908ae156914dc693a4ed
                                        
                                            GET /s/roboto/v18/KFOkCnqEu92Fr1Mu51xIIzQ.woff HTTP/1.1 
Host: fonts.gstatic.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://fonts.googleapis.com/css?family=Roboto%3A1%2C300%2C400%2C400italic%2C700&ver=4.8.7
Origin: http://sip-global.com

                                         
                                         172.217.21.131
HTTP/1.1 200 OK
Content-Type: font/woff
                                        
Accept-Ranges: bytes
Access-Control-Allow-Origin: *
Timing-Allow-Origin: *
Content-Length: 21528
Date: Tue, 27 Nov 2018 18:03:57 GMT
Expires: Wed, 27 Nov 2019 18:03:57 GMT
Last-Modified: Mon, 16 Oct 2017 17:32:47 GMT
X-Content-Type-Options: nosniff
Server: sffe
X-XSS-Protection: 1; mode=block
Cache-Control: public, max-age=31536000
Age: 1923


--- Additional Info ---
Magic:  data
Size:   21528
Md5:    9680d5a0c32d2fd084e07bbc4c8b2923
Sha1:   8020b21e3db55ff7a02100faebd92c2305e7156e
Sha256: 2cfe69657c55133dac6ea017b4452efff2131422abd9e90500a072df7ca5a9c8
                                        
                                            GET /wp-content/themes/betheme/fonts/mfn-icons.woff?23391439 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/wp-content/themes/betheme/css/base.css?ver=17.5
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: application/font-woff
                                        
Date: Tue, 27 Nov 2018 18:36:02 GMT
Server: Apache
Last-Modified: Thu, 06 Apr 2017 11:26:31 GMT
Etag: "13afc-54c7dc7d807c0"
Accept-Ranges: bytes
Content-Length: 80636
X-Powered-By: PleskLin
Keep-Alive: timeout=5, max=100
Connection: Keep-Alive


--- Additional Info ---
Magic:  data
Size:   80636
Md5:    3da843d15ed5d4d39e269cfbad8345fb
Sha1:   1d915a3fd051f9e9cf6f545dfe31939fdb368738
Sha256: f6134456d89988ada75cfdf21df40c6abdccccf01b48a669add0223f3fa38ec4
                                        
                                            POST /gsr2 HTTP/1.1 
Host: ocsp.pki.goog
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Content-Length: 112
Content-Type: application/ocsp-request

                                         
                                         172.217.22.174
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Date: Tue, 27 Nov 2018 18:36:01 GMT
Cache-Control: public, max-age=86400
Server: ocsp_responder
Content-Length: 468
X-XSS-Protection: 1; mode=block
X-Frame-Options: SAMEORIGIN


--- Additional Info ---
Magic:  data
Size:   468
Md5:    d9d754520ae3340aa37cca6115eee05b
Sha1:   a0320372760d99c762cb2eb4b37f776625ef1b33
Sha256: 7dc8284c51c9a38dc1bf03bd28857ea5336e8f5c564eddbb1c9082ee43c93738
                                        
                                            GET /wp-content/uploads/2015/01/3.jpg HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: image/png,image/*;q=0.8,*/*;q=0.5
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: image/jpeg
                                        
Date: Tue, 27 Nov 2018 18:35:39 GMT
Server: Apache
Last-Modified: Thu, 21 Sep 2017 09:54:55 GMT
Etag: "5e86f-559b01598b9c0"
Accept-Ranges: bytes
Content-Length: 387183
X-Powered-By: PleskLin
Keep-Alive: timeout=5, max=91
Connection: Keep-Alive


--- Additional Info ---
Magic:  JPEG image data, EXIF standard
Size:   387183
Md5:    6654a2f11612bfe52181397aee6fc064
Sha1:   f9d034e687f8c417a176f6cd0243672ea7825a9e
Sha256: 4c674fe2b402d94ea6b35d92f5d347ace3ee4fe8b275a6c4aca9e594f55040ed
                                        
                                            GET /s/roboto/v18/KFOmCnqEu92Fr1Mu4mxM.woff HTTP/1.1 
Host: fonts.gstatic.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://fonts.googleapis.com/css?family=Roboto:400%2C500
Origin: http://sip-global.com

                                         
                                         172.217.21.131
HTTP/1.1 200 OK
Content-Type: font/woff
                                        
Accept-Ranges: bytes
Access-Control-Allow-Origin: *
Timing-Allow-Origin: *
Content-Length: 19824
Date: Mon, 12 Nov 2018 22:37:02 GMT
Expires: Tue, 12 Nov 2019 22:37:02 GMT
Last-Modified: Mon, 16 Oct 2017 17:32:56 GMT
X-Content-Type-Options: nosniff
Server: sffe
X-XSS-Protection: 1; mode=block
Cache-Control: public, max-age=31536000
Age: 1281540


--- Additional Info ---
Magic:  data
Size:   19824
Md5:    bafb105baeb22d965c70fe52ba6b49d9
Sha1:   934014cc9bbe5883542be756b3146c05844b254f
Sha256: 1570f866bf6eae82041e407280894a86ad2b8b275e01908ae156914dc693a4ed
                                        
                                            GET /s/roboto/v18/KFOkCnqEu92Fr1Mu51xIIzQ.woff HTTP/1.1 
Host: fonts.gstatic.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://fonts.googleapis.com/css?family=Roboto%3A1%2C300%2C400%2C400italic%2C700&ver=4.8.7
Origin: http://sip-global.com

                                         
                                         172.217.21.131
HTTP/1.1 200 OK
Content-Type: font/woff
                                        
Accept-Ranges: bytes
Access-Control-Allow-Origin: *
Timing-Allow-Origin: *
Content-Length: 21528
Date: Tue, 27 Nov 2018 18:03:57 GMT
Expires: Wed, 27 Nov 2019 18:03:57 GMT
Last-Modified: Mon, 16 Oct 2017 17:32:47 GMT
X-Content-Type-Options: nosniff
Server: sffe
X-XSS-Protection: 1; mode=block
Cache-Control: public, max-age=31536000
Age: 1925


--- Additional Info ---
Magic:  data
Size:   21528
Md5:    9680d5a0c32d2fd084e07bbc4c8b2923
Sha1:   8020b21e3db55ff7a02100faebd92c2305e7156e
Sha256: 2cfe69657c55133dac6ea017b4452efff2131422abd9e90500a072df7ca5a9c8
                                        
                                            GET /wp-content/themes/betheme/fonts/mfn-icons.woff?23391439 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/wp-content/themes/betheme/css/base.css?ver=17.5
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: application/font-woff
                                        
Date: Tue, 27 Nov 2018 18:36:04 GMT
Server: Apache
Last-Modified: Thu, 06 Apr 2017 11:26:31 GMT
Etag: "13afc-54c7dc7d807c0"
Accept-Ranges: bytes
Content-Length: 80636
X-Powered-By: PleskLin
Keep-Alive: timeout=5, max=99
Connection: Keep-Alive


--- Additional Info ---
Magic:  data
Size:   80636
Md5:    3da843d15ed5d4d39e269cfbad8345fb
Sha1:   1d915a3fd051f9e9cf6f545dfe31939fdb368738
Sha256: f6134456d89988ada75cfdf21df40c6abdccccf01b48a669add0223f3fa38ec4
                                        
                                            GET /wp-content/uploads/2015/01/2.jpg HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: image/png,image/*;q=0.8,*/*;q=0.5
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: image/jpeg
                                        
Date: Tue, 27 Nov 2018 18:35:39 GMT
Server: Apache
Last-Modified: Thu, 21 Sep 2017 09:54:53 GMT
Etag: "8701a-559b0157a3540"
Accept-Ranges: bytes
Content-Length: 552986
X-Powered-By: PleskLin
Keep-Alive: timeout=5, max=93
Connection: Keep-Alive


--- Additional Info ---
Magic:  JPEG image data, EXIF standard
Size:   552986
Md5:    9d7bb560c3b73db80e70169b0e9f2d13
Sha1:   16ffefc45def0b3a2577c1f4bfe4464aa05cf7de
Sha256: 978d4c7d25a5d2c115a3b957e66ced4a8fea081a67bb14f55366f7a72a7b352d
                                        
                                            GET /wp-content/themes/betheme/images/stripes/stripes_10_w.png HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: image/png,image/*;q=0.8,*/*;q=0.5
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/wp-content/themes/betheme/css/shortcodes.css?ver=17.5
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: image/png
                                        
Date: Tue, 27 Nov 2018 18:36:05 GMT
Server: Apache
Last-Modified: Thu, 06 Apr 2017 11:26:46 GMT
Etag: "3d6-54c7dc8bce980"
Accept-Ranges: bytes
Content-Length: 982
X-Powered-By: PleskLin
Keep-Alive: timeout=5, max=98
Connection: Keep-Alive


--- Additional Info ---
Magic:  PNG image, 10 x 10, 8-bit/color RGBA, non-interlaced
Size:   982
Md5:    487e5f36fdb3f092a7f0147190cf5bf2
Sha1:   4103004cd8e7f61d51f527567253fbb5494e9dcb
Sha256: 67adb1213246a83b84ab50a14def37bb2eac8da9b26e1f329db6754bbb864d62
                                        
                                            GET /wp-content/themes/betheme/images/stripes/stripes_3_b.png HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: image/png,image/*;q=0.8,*/*;q=0.5
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/wp-content/themes/betheme/css/shortcodes.css?ver=17.5
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: image/png
                                        
Date: Tue, 27 Nov 2018 18:36:05 GMT
Server: Apache
Last-Modified: Thu, 06 Apr 2017 11:26:46 GMT
Etag: "3ce-54c7dc8bce980"
Accept-Ranges: bytes
Content-Length: 974
X-Powered-By: PleskLin
Keep-Alive: timeout=5, max=97
Connection: Keep-Alive


--- Additional Info ---
Magic:  PNG image, 10 x 10, 8-bit/color RGBA, non-interlaced
Size:   974
Md5:    b5d66cece54745f352d2d52e6195a4ee
Sha1:   7b7313014426b12f9d51e4deb9ba237f11759dcf
Sha256: 30cb91834555c22273bd8f0d521bebaff6020b2e54bae4ccfc199f4a1daaf2eb
                                        
                                            GET /s/roboto/v18/KFOlCnqEu92Fr1MmSU5fBBc-.woff HTTP/1.1 
Host: fonts.gstatic.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://fonts.googleapis.com/css?family=Roboto%3A1%2C300%2C400%2C400italic%2C700&ver=4.8.7
Origin: http://sip-global.com

                                         
                                         172.217.21.131
HTTP/1.1 200 OK
Content-Type: font/woff
                                        
Accept-Ranges: bytes
Access-Control-Allow-Origin: *
Timing-Allow-Origin: *
Content-Length: 19916
Date: Mon, 12 Nov 2018 11:50:20 GMT
Expires: Tue, 12 Nov 2019 11:50:20 GMT
Last-Modified: Mon, 16 Oct 2017 17:32:44 GMT
X-Content-Type-Options: nosniff
Server: sffe
X-XSS-Protection: 1; mode=block
Cache-Control: public, max-age=31536000
Age: 1320345


--- Additional Info ---
Magic:  data
Size:   19916
Md5:    a1471d1d6431c893582a5f6a250db3f9
Sha1:   ff5673d89e6c2893d24c87bc9786c632290e150e
Sha256: 3ab30e780c8b0bcc4998b838a5b30c3bfe28edead312906dc3c12271fae0699a
                                        
                                            GET /s/opensans/v15/mem5YaGs126MiZpBA-UN_r8OUuhv.woff HTTP/1.1 
Host: fonts.gstatic.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://fonts.googleapis.com/css?family=Open+Sans%3A1%2C300%2C400%2C400italic%2C700&ver=4.8.7
Origin: http://sip-global.com

                                         
                                         172.217.21.131
HTTP/1.1 200 OK
Content-Type: font/woff
                                        
Accept-Ranges: bytes
Access-Control-Allow-Origin: *
Timing-Allow-Origin: *
Content-Length: 18280
Date: Tue, 27 Nov 2018 18:04:51 GMT
Expires: Wed, 27 Nov 2019 18:04:51 GMT
Last-Modified: Wed, 11 Oct 2017 21:49:35 GMT
X-Content-Type-Options: nosniff
Server: sffe
X-XSS-Protection: 1; mode=block
Cache-Control: public, max-age=31536000
Age: 1874


--- Additional Info ---
Magic:  data
Size:   18280
Md5:    521d17bc9f3526c690e8ada6eee55bec
Sha1:   0c74bab4a4ebdafe080c8a35bd61d38f1b692358
Sha256: 624b3c987e1731e2871567be1451a257be8ebcaa2abebaa45651d3d95fa99492
                                        
                                            GET /s/roboto/v18/KFOlCnqEu92Fr1MmWUlfBBc-.woff HTTP/1.1 
Host: fonts.gstatic.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://fonts.googleapis.com/css?family=Roboto%3A1%2C300%2C400%2C400italic%2C700&ver=4.8.7
Origin: http://sip-global.com

                                         
                                         172.217.21.131
HTTP/1.1 200 OK
Content-Type: font/woff
                                        
Accept-Ranges: bytes
Access-Control-Allow-Origin: *
Timing-Allow-Origin: *
Content-Length: 19888
Date: Sun, 11 Nov 2018 01:23:30 GMT
Expires: Mon, 11 Nov 2019 01:23:30 GMT
Last-Modified: Mon, 16 Oct 2017 17:33:11 GMT
X-Content-Type-Options: nosniff
Server: sffe
X-XSS-Protection: 1; mode=block
Cache-Control: public, max-age=31536000
Age: 1444355


--- Additional Info ---
Magic:  data
Size:   19888
Md5:    cf6613d1adf490972c557a8e318e0868
Sha1:   b2198c3fc1c72646d372f63e135e70ba2c9fed8e
Sha256: 468e579fe1210fa55525b1c470ed2d1958404512a2dd4fb972cac5ce0ff00b1f
                                        
                                            GET /s/opensans/v15/mem5YaGs126MiZpBA-UN7rgOUuhv.woff HTTP/1.1 
Host: fonts.gstatic.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://fonts.googleapis.com/css?family=Open+Sans%3A1%2C300%2C400%2C400italic%2C700&ver=4.8.7
Origin: http://sip-global.com

                                         
                                         172.217.21.131
HTTP/1.1 200 OK
Content-Type: font/woff
                                        
Accept-Ranges: bytes
Access-Control-Allow-Origin: *
Timing-Allow-Origin: *
Content-Length: 18476
Date: Tue, 27 Nov 2018 14:14:46 GMT
Expires: Wed, 27 Nov 2019 14:14:46 GMT
Last-Modified: Wed, 11 Oct 2017 21:49:43 GMT
X-Content-Type-Options: nosniff
Server: sffe
X-XSS-Protection: 1; mode=block
Cache-Control: public, max-age=31536000
Age: 15679


--- Additional Info ---
Magic:  data
Size:   18476
Md5:    623e3205570002af47fc2b88f9335d19
Sha1:   b5f79d1934da79c8a4ba381092dad82ffb0582cb
Sha256: 5e03e0c7668266486cab9529702019d75c219fcec2b1e82a7c11797ba9b78506
                                        
                                            GET /wp-content/themes/betheme/fonts/mfn-icons.woff?23391439 HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/wp-content/themes/betheme/css/base.css?ver=17.5
Cookie: pll_language=en
If-Modified-Since: Thu, 06 Apr 2017 11:26:31 GMT
If-None-Match: "13afc-54c7dc7d807c0"

                                         
                                         185.45.75.168
HTTP/1.1 304 Not Modified
                                        
Date: Tue, 27 Nov 2018 18:36:09 GMT
Server: Apache
Connection: Keep-Alive
Keep-Alive: timeout=5, max=96
Etag: "13afc-54c7dc7d807c0"


--- Additional Info ---
                                        
                                            GET /s/roboto/v18/KFOlCnqEu92Fr1MmSU5fBBc-.woff HTTP/1.1 
Host: fonts.gstatic.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://fonts.googleapis.com/css?family=Roboto%3A1%2C300%2C400%2C400italic%2C700&ver=4.8.7
Origin: http://sip-global.com

                                         
                                         172.217.21.131
HTTP/1.1 200 OK
Content-Type: font/woff
                                        
Accept-Ranges: bytes
Access-Control-Allow-Origin: *
Timing-Allow-Origin: *
Content-Length: 19916
Date: Mon, 12 Nov 2018 11:50:20 GMT
Expires: Tue, 12 Nov 2019 11:50:20 GMT
Last-Modified: Mon, 16 Oct 2017 17:32:44 GMT
X-Content-Type-Options: nosniff
Server: sffe
X-XSS-Protection: 1; mode=block
Cache-Control: public, max-age=31536000
Age: 1320347


--- Additional Info ---
Magic:  data
Size:   19916
Md5:    a1471d1d6431c893582a5f6a250db3f9
Sha1:   ff5673d89e6c2893d24c87bc9786c632290e150e
Sha256: 3ab30e780c8b0bcc4998b838a5b30c3bfe28edead312906dc3c12271fae0699a
                                        
                                            GET /s/opensans/v15/mem5YaGs126MiZpBA-UN_r8OUuhv.woff HTTP/1.1 
Host: fonts.gstatic.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://fonts.googleapis.com/css?family=Open+Sans%3A1%2C300%2C400%2C400italic%2C700&ver=4.8.7
Origin: http://sip-global.com

                                         
                                         172.217.21.131
HTTP/1.1 200 OK
Content-Type: font/woff
                                        
Accept-Ranges: bytes
Access-Control-Allow-Origin: *
Timing-Allow-Origin: *
Content-Length: 18280
Date: Tue, 27 Nov 2018 18:04:51 GMT
Expires: Wed, 27 Nov 2019 18:04:51 GMT
Last-Modified: Wed, 11 Oct 2017 21:49:35 GMT
X-Content-Type-Options: nosniff
Server: sffe
X-XSS-Protection: 1; mode=block
Cache-Control: public, max-age=31536000
Age: 1876


--- Additional Info ---
Magic:  data
Size:   18280
Md5:    521d17bc9f3526c690e8ada6eee55bec
Sha1:   0c74bab4a4ebdafe080c8a35bd61d38f1b692358
Sha256: 624b3c987e1731e2871567be1451a257be8ebcaa2abebaa45651d3d95fa99492
                                        
                                            GET /s/roboto/v18/KFOlCnqEu92Fr1MmWUlfBBc-.woff HTTP/1.1 
Host: fonts.gstatic.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://fonts.googleapis.com/css?family=Roboto%3A1%2C300%2C400%2C400italic%2C700&ver=4.8.7
Origin: http://sip-global.com

                                         
                                         172.217.21.131
HTTP/1.1 200 OK
Content-Type: font/woff
                                        
Accept-Ranges: bytes
Access-Control-Allow-Origin: *
Timing-Allow-Origin: *
Content-Length: 19888
Date: Sun, 11 Nov 2018 01:23:30 GMT
Expires: Mon, 11 Nov 2019 01:23:30 GMT
Last-Modified: Mon, 16 Oct 2017 17:33:11 GMT
X-Content-Type-Options: nosniff
Server: sffe
X-XSS-Protection: 1; mode=block
Cache-Control: public, max-age=31536000
Age: 1444357


--- Additional Info ---
Magic:  data
Size:   19888
Md5:    cf6613d1adf490972c557a8e318e0868
Sha1:   b2198c3fc1c72646d372f63e135e70ba2c9fed8e
Sha256: 468e579fe1210fa55525b1c470ed2d1958404512a2dd4fb972cac5ce0ff00b1f
                                        
                                            GET /s/opensans/v15/mem5YaGs126MiZpBA-UN7rgOUuhv.woff HTTP/1.1 
Host: fonts.gstatic.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://fonts.googleapis.com/css?family=Open+Sans%3A1%2C300%2C400%2C400italic%2C700&ver=4.8.7
Origin: http://sip-global.com

                                         
                                         172.217.21.131
HTTP/1.1 200 OK
Content-Type: font/woff
                                        
Accept-Ranges: bytes
Access-Control-Allow-Origin: *
Timing-Allow-Origin: *
Content-Length: 18476
Date: Tue, 27 Nov 2018 14:14:46 GMT
Expires: Wed, 27 Nov 2019 14:14:46 GMT
Last-Modified: Wed, 11 Oct 2017 21:49:43 GMT
X-Content-Type-Options: nosniff
Server: sffe
X-XSS-Protection: 1; mode=block
Cache-Control: public, max-age=31536000
Age: 15681


--- Additional Info ---
Magic:  data
Size:   18476
Md5:    623e3205570002af47fc2b88f9335d19
Sha1:   b5f79d1934da79c8a4ba381092dad82ffb0582cb
Sha256: 5e03e0c7668266486cab9529702019d75c219fcec2b1e82a7c11797ba9b78506
                                        
                                            GET /recaptcha/api.js?onload=recaptchaCallback&render=explicit&ver=2.0 HTTP/1.1 
Host: www.google.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/

                                         
                                         216.58.207.196
HTTP/1.1 200 OK
Content-Type: text/javascript; charset=UTF-8
                                        
Expires: Tue, 27 Nov 2018 18:36:11 GMT
Date: Tue, 27 Nov 2018 18:36:11 GMT
Cache-Control: private, max-age=300
Content-Encoding: gzip
X-Content-Type-Options: nosniff
X-Frame-Options: SAMEORIGIN
X-XSS-Protection: 1; mode=block
Server: GSE
Alt-Svc: quic=":443"; ma=2592000; v="44,43,39,35"
Transfer-Encoding: chunked


--- Additional Info ---
Magic:  gzip compressed data, from FAT filesystem (MS-DOS, OS/2, NT)
Size:   481
Md5:    5e0585ff2d0f6c3969afd6a2460785d3
Sha1:   234d560087c15c1128c178e13a6c0281cf230369
Sha256: da22b35068e5a795bae718515831d030dc3d4853460d7057bc070704729e76b4
                                        
                                            GET /wp-content/uploads/2015/01/parallax.jpg HTTP/1.1 
Host: sip-global.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: image/png,image/*;q=0.8,*/*;q=0.5
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/
Cookie: pll_language=en

                                         
                                         185.45.75.168
HTTP/1.1 200 OK
Content-Type: image/jpeg
                                        
Date: Tue, 27 Nov 2018 18:35:39 GMT
Server: Apache
Last-Modified: Thu, 07 Sep 2017 15:25:49 GMT
Etag: "1809a7-5589b13357940"
Accept-Ranges: bytes
Content-Length: 1575335
X-Powered-By: PleskLin
Keep-Alive: timeout=5, max=93
Connection: Keep-Alive


--- Additional Info ---
Magic:  JPEG image data, EXIF standard
Size:   1575335
Md5:    5e25c8b29788e93f3a827342e07b8e13
Sha1:   6d8d3f88b30711ca81b5b44214f5a9c9398c7024
Sha256: 208849e90392cc6e11212477ca33364ee77c38639aae37aaf117ed62cfa5a74c
                                        
                                            POST /GTSGIAG3 HTTP/1.1 
Host: ocsp.pki.goog
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Content-Length: 107
Content-Type: application/ocsp-request

                                         
                                         172.217.22.174
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Date: Tue, 27 Nov 2018 18:36:12 GMT
Cache-Control: public, max-age=86400
Server: ocsp_responder
Content-Length: 463
X-XSS-Protection: 1; mode=block
X-Frame-Options: SAMEORIGIN


--- Additional Info ---
Magic:  data
Size:   463
Md5:    75f3354e31f1702aaa271acc125e9555
Sha1:   cf3dd15a1826b3a53b303f4f7d04388c7b15ce64
Sha256: 8d9d7fd41646d6942d8e031216e7c7acd081c3f903c44abc2e0c2d7e8b0f0819
                                        
                                            POST /gsr2 HTTP/1.1 
Host: ocsp.pki.goog
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Content-Length: 112
Content-Type: application/ocsp-request

                                         
                                         172.217.22.174
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Date: Tue, 27 Nov 2018 18:36:12 GMT
Cache-Control: public, max-age=86400
Server: ocsp_responder
Content-Length: 468
X-XSS-Protection: 1; mode=block
X-Frame-Options: SAMEORIGIN


--- Additional Info ---
Magic:  data
Size:   468
Md5:    d9d754520ae3340aa37cca6115eee05b
Sha1:   a0320372760d99c762cb2eb4b37f776625ef1b33
Sha256: 7dc8284c51c9a38dc1bf03bd28857ea5336e8f5c564eddbb1c9082ee43c93738
                                        
                                            GET /recaptcha/api2/v1542004393985/recaptcha__en.js HTTP/1.1 
Host: www.gstatic.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/

                                         
                                         172.217.21.131
HTTP/1.1 200 OK
Content-Type: text/javascript
                                        
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
Content-Length: 91567
Date: Wed, 14 Nov 2018 19:17:17 GMT
Expires: Thu, 14 Nov 2019 19:17:17 GMT
Last-Modified: Mon, 12 Nov 2018 17:45:00 GMT
X-Content-Type-Options: nosniff
Server: sffe
X-XSS-Protection: 1; mode=block
Cache-Control: public, max-age=31536000
Age: 1120735
Alt-Svc: quic=":443"; ma=2592000; v="44,43,39,35"


--- Additional Info ---
Magic:  gzip compressed data, max compression
Size:   91567
Md5:    058e1bb27296e6afdbb253d32c211604
Sha1:   ea123c722fddd8516cf0fc6675361377477951b5
Sha256: 3884d3318556071a5b90b696e30e8e0ebe825728419b42bbd16471bc76df956e
                                        
                                            GET /recaptcha/api/fallback?k=6Lc-IjsUAAAAAEXXugciTEz8jbP4ICiKLeg13Adw&hl=en&v=v1542004393985&t=8&ff=true HTTP/1.1 
Host: www.google.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/

                                         
                                         216.58.207.196
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
                                        
Content-Encoding: gzip
Date: Tue, 27 Nov 2018 18:36:12 GMT
Expires: Tue, 27 Nov 2018 18:36:12 GMT
Cache-Control: private, max-age=0
X-Content-Type-Options: nosniff
X-XSS-Protection: 1; mode=block
Server: GSE
Alt-Svc: quic=":443"; ma=2592000; v="44,43,39,35"
Transfer-Encoding: chunked


--- Additional Info ---
Magic:  gzip compressed data, from FAT filesystem (MS-DOS, OS/2, NT)
Size:   568
Md5:    c9eb33756203a4f576bea222074205bb
Sha1:   1525c38b19a89df3f4898e8e9367bfce7c5ec40a
Sha256: d0f598fe935472038b875337c2561e3c1e4a02dd14c70f342f6d7ee0faf06b57
                                        
                                            GET /recaptcha/api2/v1542004393985/fallback__ltr.css HTTP/1.1 
Host: www.gstatic.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/css,*/*;q=0.1
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.google.com/recaptcha/api/fallback?k=6Lc-IjsUAAAAAEXXugciTEz8jbP4ICiKLeg13Adw&hl=en&v=v1542004393985&t=8&ff=true

                                         
                                         172.217.21.131
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Accept-Ranges: bytes
Vary: Accept-Encoding
Content-Encoding: gzip
Content-Length: 1298
Date: Wed, 14 Nov 2018 19:24:47 GMT
Expires: Thu, 14 Nov 2019 19:24:47 GMT
Last-Modified: Mon, 12 Nov 2018 17:45:00 GMT
X-Content-Type-Options: nosniff
Server: sffe
X-XSS-Protection: 1; mode=block
Cache-Control: public, max-age=31536000
Age: 1120286
Alt-Svc: quic=":443"; ma=2592000; v="44,43,39,35"


--- Additional Info ---
Magic:  gzip compressed data, max compression
Size:   1298
Md5:    d8c078f55977ebb27fc9b2d09cf45aa1
Sha1:   1810ca3d2e5c4dde09e54aef79861a5375c7eeae
Sha256: 34c2d201ab9b4701c7000017146e268e489375a4e92bea78fc0cd378607f49c1
                                        
                                            POST /GTSGIAG3 HTTP/1.1 
Host: ocsp.pki.goog
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Content-Length: 107
Content-Type: application/ocsp-request

                                         
                                         172.217.22.174
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Date: Tue, 27 Nov 2018 18:36:13 GMT
Cache-Control: public, max-age=86400
Server: ocsp_responder
Content-Length: 463
X-XSS-Protection: 1; mode=block
X-Frame-Options: SAMEORIGIN


--- Additional Info ---
Magic:  data
Size:   463
Md5:    5a5bcdcbebaec7e89d571d0941d87d5a
Sha1:   19d83edcc1273cf30bf5f22d0c455c0fb6eb1cf5
Sha256: 98b8f461f70e80da438f5be8bf60245401f242cb5247ed374a7c1e70387eb7c7
                                        
                                            GET /css?family=Roboto:400,500 HTTP/1.1 
Host: fonts.googleapis.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/css,*/*;q=0.1
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.gstatic.com/recaptcha/api2/v1542004393985/fallback__ltr.css

                                         
                                         172.217.21.170
HTTP/1.1 200 OK
Content-Type: text/css; charset=utf-8
                                        
Access-Control-Allow-Origin: *
Timing-Allow-Origin: *
Expires: Tue, 27 Nov 2018 18:36:13 GMT
Date: Tue, 27 Nov 2018 18:36:13 GMT
Cache-Control: private, max-age=86400
Content-Encoding: gzip
Server: ESF
X-XSS-Protection: 1; mode=block
X-Frame-Options: SAMEORIGIN
Alt-Svc: quic=":443"; ma=2592000; v="44,43,39,35"
Transfer-Encoding: chunked


--- Additional Info ---
Magic:  gzip compressed data, max compression
Size:   223
Md5:    8595ba4810324fe73aeb112dcf8b009a
Sha1:   5d412083d9195340b4e7fdcf6cbae20b1de34db6
Sha256: e45c189d05b97ed1655cd96cbe690d2290588e92d5dfa9fbd60fc64795b5ade1
                                        
                                            GET /recaptcha/api2/logo_48.png HTTP/1.1 
Host: www.gstatic.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: image/png,image/*;q=0.8,*/*;q=0.5
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.gstatic.com/recaptcha/api2/v1542004393985/fallback__ltr.css

                                         
                                         172.217.21.131
HTTP/1.1 200 OK
Content-Type: image/png
                                        
Accept-Ranges: bytes
Content-Length: 2228
Date: Thu, 22 Nov 2018 08:12:29 GMT
Expires: Thu, 29 Nov 2018 08:12:29 GMT
Last-Modified: Thu, 21 Apr 2016 03:17:22 GMT
X-Content-Type-Options: nosniff
Server: sffe
X-XSS-Protection: 1; mode=block
Cache-Control: public, max-age=604800
Age: 469424
Alt-Svc: quic=":443"; ma=2592000; v="44,43,39,35"


--- Additional Info ---
Magic:  PNG image, 48 x 48, 8-bit/color RGBA, non-interlaced
Size:   2228
Md5:    ef9941290c50cd3866e2ba6b793f010d
Sha1:   4736508c795667dcea21f8d864233031223b7832
Sha256: 1b9efb22c938500971aac2b2130a475fa23684dd69e43103894968df83145b8a
                                        
                                            GET /s/roboto/v18/KFOmCnqEu92Fr1Mu4mxM.woff HTTP/1.1 
Host: fonts.gstatic.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://fonts.googleapis.com/css?family=Roboto:400,500
Origin: https://www.google.com

                                         
                                         172.217.21.131
HTTP/1.1 200 OK
Content-Type: font/woff
                                        
Accept-Ranges: bytes
Access-Control-Allow-Origin: *
Timing-Allow-Origin: *
Content-Length: 19824
Date: Mon, 12 Nov 2018 23:33:42 GMT
Expires: Tue, 12 Nov 2019 23:33:42 GMT
Last-Modified: Mon, 16 Oct 2017 17:32:56 GMT
X-Content-Type-Options: nosniff
Server: sffe
X-XSS-Protection: 1; mode=block
Cache-Control: public, max-age=31536000
Age: 1278151
Alt-Svc: quic=":443"; ma=2592000; v="44,43,39,35"


--- Additional Info ---
Magic:  data
Size:   19824
Md5:    bafb105baeb22d965c70fe52ba6b49d9
Sha1:   934014cc9bbe5883542be756b3146c05844b254f
Sha256: 1570f866bf6eae82041e407280894a86ad2b8b275e01908ae156914dc693a4ed
                                        
                                            GET /recaptcha/api.js?onload=recaptchaCallback&render=explicit&ver=2.0 HTTP/1.1 
Host: www.google.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: http://sip-global.com/en/

                                         
                                         0.0.0.0
                                        


--- Additional Info ---