Overview

URL trustweb.website
IP204.93.177.101
ASNAS23352 Server Central Network
Location United States
Report completed2017-09-13 16:08:03 CEST
StatusLoading report..
urlQuery Alerts Phishing website 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  No alerts detected


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: 204.93.177.101

Date UQ / IDS / BL URL IP
2017-09-22 07:51:33 +0200
0 - 0 - 1 www.24techniquesforclosingthesale.com/images/ (...) 204.93.177.101
2017-09-20 01:27:25 +0200
1 - 0 - 0 myaccount.website/ 204.93.177.101
2017-09-19 17:05:52 +0200
0 - 0 - 0 steamuptown.review 204.93.177.101
2017-09-19 16:57:14 +0200
0 - 0 - 0 https://www.steamuptown.review/ 204.93.177.101
2017-09-19 14:30:56 +0200
0 - 0 - 0 www.steamuptown.review 204.93.177.101
2017-09-18 12:54:27 +0200
1 - 0 - 0 myaccount.website/ 204.93.177.101
2017-09-18 09:01:30 +0200
1 - 0 - 0 myaccount.website/ 204.93.177.101
2017-09-18 02:59:33 +0200
0 - 0 - 1 bordesnusantara.co.id/cv/dpbx/dpbx 204.93.177.101
2017-09-17 23:07:58 +0200
0 - 0 - 1 www.bordesnusantara.co.id/cv/dpbx/dpbx 204.93.177.101
2017-09-17 21:52:57 +0200
1 - 0 - 0 myaccount.website/ 204.93.177.101

Last 10 reports on ASN: AS23352 Server Central Network

Date UQ / IDS / BL URL IP
2017-09-24 21:54:05 +0200
0 - 0 - 7 rumahsehatalami.com/ 66.225.221.38
2017-09-24 21:04:40 +0200
0 - 0 - 6 www.rumahsehatalami.com/ 66.225.221.38
2017-09-24 17:59:08 +0200
0 - 0 - 1 mobici.be/ 198.38.86.67
2017-09-24 17:52:31 +0200
0 - 0 - 6 www.rumahsehatalami.com/ 66.225.221.38
2017-09-24 17:52:31 +0200
0 - 0 - 7 rumahsehatalami.com/ 66.225.221.38
2017-09-24 17:07:27 +0200
0 - 0 - 4 profosinubi.org/Bah/index.html 198.38.91.121
2017-09-24 16:54:26 +0200
0 - 0 - 1 muzikworld.com/invoice-number-015532 50.31.162.124
2017-09-24 16:09:29 +0200
0 - 0 - 15 www.jmsuministros.com/ 204.93.248.96
2017-09-24 15:36:01 +0200
0 - 0 - 1 www.pependo.it/bofaaa/d3392c1fb002e076e565c25 (...) 198.38.82.122
2017-09-24 14:54:24 +0200
0 - 0 - 6 www.rumahsehatalami.com/ 66.225.221.38

Last 2 reports on domain: trustweb.website

Date UQ / IDS / BL URL IP
2017-09-13 01:35:39 +0200
1 - 0 - 0 trustweb.website 204.93.177.101
2017-09-13 01:00:30 +0200
1 - 0 - 0 trustweb.website/ 204.93.177.101


JavaScript

Executed Scripts (47)


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: 188558, repeated: 1) - SHA256: 2064d38a689b65b1878953e0218d20e74a9d6454e2a2a02f732d6549fa29a87d

                                        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);
            if (window._layerSlider.checkVersions(g, h, g)) return (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
            });
            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,
                        hashChange: !1,
                        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"],
                        globalhover: ["data", "globalhover"]
                    },
                    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 || -1 !== a.loop.startAt.indexOf("textinstart") && -1 !== a.loop.startAt.indexOf("textinend") && -1 !== a.loop.startAt.indexOf("allinend")) ? (this.loopstart = f.transitions.layers.timeline.getTiming(a, a.loop.startAt, "loopstart"), this.loopend = -1 !== a.loop.count && 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,
                first: {},
                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] && void 0 !== g[o[0]] && (p = void 0 === g[o[0]][1] ? o[0] : g[o[0]][1], q = f.functions.convert.properties(o[1]), -1 === p.toLowerCase().indexOf("duration") && -1 === p.toLowerCase().indexOf("delay") && "timeShift" != p || (q /= 1e3), l[g[o[0]][0]][p] = q)
                            }
                        if (j.children("a.ls-link").length && (l.data.$link = j.children("a.ls-link").first().css({
                                zIndex: 5
                            }).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) {
                            var r;
                            j.find("> .ls-tn").length ? r = j.find("> .ls-tn").first() : j.find("> .ls-bg").length && (r = j.find("> .ls-bg").first()), r ? (l.data.thumbnail = f.functions.getURL(r), l.data.tnAlt = f.functions.getALT(r)) : 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 = -1 !== b.prev.index ? a.extend(!0, {}, b[b.prev.index]) : {}, b.current = -1 !== b.current.index ? a.extend(!0, {}, b[b.current.index]) : {}, b.next = -1 !== b.next.index ? 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)
                    }
                },
                get: {
                    deeplink: function(a) {
                        return a && f.slides[a] && f.slides[a].data && f.slides[a].data.deeplink ? f.slides[a].data.deeplink : null
                    }
                },
                slide: []
            }, f.layers = {
                $all: a(),
                getStyle: function(a, b) {
                    return -1 != a.indexOf("%") ? 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 (-1 != k.attr("class").indexOf("ls-s")) {
                            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)), -1 !== k.attr("class").indexOf("ls-linkto-") && 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 && -1 !== d.indexOf("ls-scroll") && 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
                                })
                            }), -1 !== f.defaults.init.controls.indexOf(c) || c.match(/^\#[0-9]/)) {
                            var h = a.trim(c.toLowerCase().split("#")[1]),
                                i = parseInt(h);
                            b.on("click." + e, function(a) {
                                if (a.preventDefault(), -1 !== ["prev", "next", "start", "stop"].indexOf(h)) 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++) - 1 != d[h].indexOf("ls-linkto-") && (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.slides[c].data.globalhover && 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 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 ? (-1 === M.width.indexOf("%") ? j = parseInt(M.width) : (n = parseInt(M.width), j = e.getStyle(M.width, f.slider.initial.percW)), -1 === M.height.indexOf("%") ? 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, -1 !== d.width.indexOf("%") && (n = parseInt(d.width)), j = "" !== j && "auto" !== j ? e.getStyle(j, f.slider.initial.percW) : H - r - t - y - A, j = j || "auto"), k || (k = d.height, -1 !== d.height.indexOf("%") && (o = parseInt(d.height)), k = "" !== k && "auto" !== k ? e.getStyle(k, f.slider.initial.percH) : I - s - u - z - B, k = k || "auto"), F = 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)), 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 && -1 !== a.indexOf("px ") && (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,
                            styleWidth: d.width,
                            styleHeight: d.height,
                            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])))
                                        if (o.replace("split", "text"), void 0 !== 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] && -1 !== n[1].indexOf("random") && (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], void 0 !== 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)/) && -1 !== s.toString().indexOf("random") ? 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)), void 0 !== e.inLayerStyleShouldBeConvertedFrom.borderRadius && (e.inLayerStyleShouldBeConvertedTo.borderRadius = e.original.borderRadius), void 0 !== 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), void 0 !== e.inLayerStyleShouldBeConvertedFrom.width && (e.inLayerStyleShouldBeConvertedTo.width = e.original.width), void 0 !== e.outLayerStyleShouldBeConvertedTo.width && (e.outLayerStyleShouldBeConvertedFrom.width = e.original.width), void 0 !== e.inLayerStyleShouldBeConvertedFrom.height && (e.inLayerStyleShouldBeConvertedTo.height = e.original.height), void 0 !== e.outLayerStyleShouldBeConvertedTo.height && (e.outLayerStyleShouldBeConvertedFrom.height = e.original.height), void 0 !== e.out.showUntil && 0 !== e.out.showUntil && (e.out.startAt = "transitioninend + " + e.out.showUntil), -1 !== e.out.startAt.indexOf("slidechangeonly") && "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 || -1 === e.loop.count) && !1 !== e.loop.enabled ? (e.loop.enabled = !0, e.loopTo.ease = e.loopClipTo.ease = f.functions.convert.easing(e.loop.ease), -1 !== e.loop.count ? 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.hoverShouldBeConverted.x || e.hoverShouldBeConverted.y || e.hoverShouldBeConverted.borderRadius || e.hoverShouldBeConverted.filter) && !1 !== e.hover.enabled ? (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.hover.enabled = !1, e.parallax.level && a.isNumeric(e.parallax.level) && 0 !== e.parallax.level && !1 !== e.parallax.enabled ? 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 && -1 === f.defaults.layer.splitTypeKeys.indexOf(e.textIn.type) && (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 && -1 === f.defaults.layer.splitTypeKeys.indexOf(e.textOut.type) && (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)), -1 !== e.textIn.split.indexOf("chars") && -1 === e.textIn.split.indexOf("words") && (e.textIn.split += ", words"), -1 !== e.textIn.split.indexOf("words") && -1 === e.textIn.split.indexOf("lines") && (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), void 0 !== 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")'; - 1 == a.indexOf("bgvideo") && -1 == a.indexOf("backgroundvideo") || (h = "", a = a.replace("bgvideo", "").replace("backgroundvideo", "")), -1 != a.indexOf("video") && (e += ", > video", a = a.replace("video", "")), -1 != a.indexOf("audio") && (e += ", > audio", a = a.replace("audio", "")), -1 != a.indexOf("html5") && (e += ", > video, > audio", a = a.replace("html5", "")), -1 != a.indexOf("youtube") && (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", "")), -1 != a.indexOf("vimeo") && (e += ', > iframe[src*="player.vimeo"], > iframe[data-src*="player.vimeo"]', a = a.replace("vimeo", "")), "," == e.charAt(0) && (e = e.substring(2, e.length)), -1 != a.indexOf("out") && (c = "out"), -1 == a.indexOf("img") && -1 == a.indexOf("image") || (d = "img"), -1 == a.indexOf("bg") && -1 == a.indexOf("background") && -1 == a.indexOf("bgonly") || (g = ""), b = -1 != a.indexOf("current") ? b.filter(d + "[data-slide" + c + '="' + f.slides.current.index + '"]' + g + h) : -1 != a.indexOf("next") ? b.filter(d + "[data-slide" + c + '="' + f.slides.next.index + '"]' + g + h) : b.filter(d + g + h), -1 != a.indexOf("notactive") && (b = b.filter(".ls-bg, .ls-bg-video, :hidden"), a = a.replace("notactive", "")), -1 != a.indexOf("active") && (b = b.filter(":visible:not(.ls-bg, .ls-bg-video)"), a = a.replace("active", "")), -1 != a.indexOf("notstatic") && (b = b.filter(':not([data-static="1"])'), a = a.replace("notstatic", "")), -1 != a.indexOf("static") && (b = b.filter('[data-static="1"]'), a = a.replace("static", "")), -1 != a.indexOf("bgonly") && (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), !0 === l && 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 = !0 === f.o.pauseOnHover ? f.defaults.init.options.pauseOnHover : f.o.pauseOnHover, !1 !== f.o.pauseOnHover && 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 (!1 === h) return;
                        a.isNumeric(h) && (d = parseInt(h))
                    }
                    if (d > f.slides.count || d < 1) return void(f.debugMode && (f.debug.add("group", "slideshow"), f.debug.add("warn", "slideshow.invalidSlideIndex", [d, f.slides.count]), f.debug.groupEnd()));
                    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() {
                    -1 != document.location.href.indexOf("https:") && (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 = -1 === g.indexOf("http") ? f.media.protocol : "",
                                i = -1 === g.indexOf("?") ? "?" : "&",
                                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 = -1 === h.indexOf("?") ? "?" : "&",
                                        j = -1 === h.indexOf("http") ? 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") && -1 !== c.data("ls").indexOf("poster:") && 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") && -1 !== b.data("ls").indexOf("poster:") && (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 || void 0 === 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), !1 !== f.o.yourLogoLink && 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") && -1 != this.$element.data("originalLeft").indexOf("%") ? 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") && -1 != this.$element.data("originalRight").indexOf("%") ? 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") && -1 != this.$element.data("originalTop").indexOf("%") ? 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") && -1 != this.$element.data("originalBottom").indexOf("%") ? 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) {
                                    void 0 === 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>');
                                    f.slides[g].data.tnAlt && h.find("img").attr("alt", f.slides[g].data.tnAlt), 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 || 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 = -1 == f.slider.initial.width.indexOf("%") ? parseInt(f.slider.initial.originalWidth) : c.width(),
                                    b = c.find(".ls-thumbnail"),
                                    d = -1 == f.o.tnContainerWidth.indexOf("%") ? 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 || (!0 === f.transitions.layers.timeline.state.started ? 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
                    }), !0 === f.slideshow.state.pausedByLastCycle && 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 (!0 !== f.slides[b].wrapped) {
                        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") && -1 !== g.css("background-image").indexOf("url") && 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++) {
                        (new Image).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() {
                    if (!document.body.contains(b)) return !1;
                    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)), 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"), -1 !== k.indexOf("%") && (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 && "fitwidth" !== 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;
                                    break;
                                case "fitwidth":
                                    g = c.parent().width() - e.skinWidth, h = f.device.viewportHeight - 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;
                    var r = c.offset();
                    f.slider.offsetX = r.left, f.slider.offsetY = r.top, 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++) - 1 === c[g].indexOf("%") ? d += Math.ceil(parseInt(c[g]) * e) + "px " : d += 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 && -1 !== f.o.maxRatio ? g.width : g.layersWidth,
                            r = "responsive" === g.type && -1 !== f.o.maxRatio ? 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 = void 0 !== 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 = void 0 !== 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:
                                            -1 !== z[0].indexOf("%") ? E.x = (f.slider.width - E.width) / 100 * parseInt(z[0]) : E.x = parseInt(z[0])
                                    }
                                    if (void 0 !== 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:
                                            -1 !== z[1].indexOf("%") ? 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, -1 != x.left.indexOf("%") ? "100%" === x.left ? E.left = 0 === C ? f.slider.width / 100 * parseInt(x.left) - E.outerWidth : C + q * d / 100 * parseInt(x.left) - E.outerWidth : "0%" === x.left ? E.left = 0 === C ? 0 : C : E.left = 0 === C ? f.slider.width / 100 * parseInt(x.left) - E.outerWidth / 2 : C + q * d / 100 * parseInt(x.left) - E.outerWidth / 2 : E.left = C + parseInt(x.left) * d, F.left = E.left, -1 != x.top.indexOf("%") ? "100%" === x.top ? E.top = 0 === D ? f.slider.height / 100 * parseInt(x.top) - E.outerHeight : D + r * d / 100 * parseInt(x.top) - E.outerHeight : "0%" === x.top ? E.top = 0 === D ? 0 : D + 0 : E.top = 0 === D ? f.slider.height / 100 * parseInt(x.top) - E.outerHeight / 2 : 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]))
                        }
                        void 0 !== 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") : void 0 !== 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") : void 0 !== 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) {
                    void 0 !== c.width && (a.isNumeric(c.width) ? b.width = parseInt(c.width) * f.resize.ratio : "string" == typeof c.width && -1 !== c.width.indexOf("%") && (b.width = f.slider.width / 100 * parseInt(c.width))), void 0 !== c.height && (a.isNumeric(c.height) ? b.height = parseInt(c.height) * f.resize.ratio : "string" == typeof c.height && -1 !== c.height.indexOf("%") && (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 = -1 === c.indexOf(",") ? c.split(" ") : c.split(","), j = "", l = 0; l < i.length; l++)
                        if (-1 !== i[l].indexOf("%")) 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 = -1 != g.left.indexOf("%") ? "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 = -1 != g.left.indexOf("%") ? "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 = -1 != g.top.indexOf("%") ? "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 = -1 != g.top.indexOf("%") ? "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 = -1 !== b.indexOf("%") ? h["outer" + c] / 100 * parseInt(b) : -1 !== b.indexOf("sw") ? parseInt(b.split("sw")[0]) / 100 * f.slider.width : -1 !== b.indexOf("sh") ? parseInt(b.split("lw")[0]) / 100 * f.slider.height : -1 !== b.indexOf("lw") ? h.outerWidth / 100 * parseInt(b.split("lw")[0]) : -1 !== b.indexOf("lh") ? 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() {
                    if (!document.body.contains(b)) return !1;
                    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(), 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 (void 0 !== 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)) : void 0 === f.transitions.curSlide.data.$background && void 0 === 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") : !0 === f.o.clipSlideTransition && f.device.$overflowWrapper.addClass("ls-overflow-hidden"), void 0 !== 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 = void 0 !== b ? " rotate(" + b.rotation + "deg)" : " rotate(0deg)", c.responsive.kbScale = void 0 !== 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 && (void 0 !== 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.o.hashChange && (document.location.hash = f.slides[f.slides.current.index].data.deeplink || "_no-deeplink-found_"), 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(), void 0 !== f.transitions.curSlide.data && void 0 !== 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 b;
                        if (f.slides.current.data.globalhover) {
                            var d = f.layers.get("current,in,notactive").add(f.layers.get("static,active"));
                            f.slider.$innerWrapper.on("mouseenter." + e, function() {
                                d.each(function() {
                                    f.transitions.layers.hover.mouseEnter(a(this), a(this).data(f.defaults.init.dataKey))
                                })
                            }), f.slider.$innerWrapper.on("mouseleave." + e, function() {
                                d.each(function() {
                                    f.transitions.layers.hover.mouseLeave(a(this), a(this).data(f.defaults.init.dataKey))
                                })
                            })
                        } else f.slider.$innerWrapper.off("mouseenter." + e, "mouseleave." + e);
                        void 0 !== 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, !1 !== f.slideshow.should.change && f.navigation.forceDirection ? (void 0 !== f.transitions.curSlide.data && void 0 !== f.transitions.curSlide.data.$background && (b = f.transitions.curSlide.data.$background.data(f.defaults.init.dataKey), 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
                        })), 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 || -1 != c.indexOf("1") || -1 != c.indexOf("2") || -1 != c.indexOf("3") || -1 != c.indexOf("4")) ? 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 g, c = -1 == a.indexOf("custom") ? f.t : f.ct,
                                    d = "3d";
                                if (-1 != a.indexOf("2d") && (d = "2d"), -1 != b.indexOf("last")) g = c["t" + d].length - 1, "last";
                                else if (-1 != b.indexOf("all")) g = Math.floor(Math.random() * f.functions.countProp(c["t" + d])), "random from all";
                                else {
                                    var h = b.split(","),
                                        i = h.length;
                                    g = parseInt(h[Math.floor(Math.random() * i)]) - 1, "random from specified"
                                }
                                void 0 === c["t" + d][g] && (f.debugMode && f.debug.add("warn", "slideTransition.customTransition", [d.toUpperCase() + (-1 === a.indexOf("custom") ? "" : " (CUSTOM)"), g + 1]), c = f.t, a = d = "2d", g = 0), f.debugMode && f.debug.add("log", "slideTransition.info", [d.toUpperCase() + (-1 === a.indexOf("custom") ? "" : " (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 = -1 != d.name.toLowerCase().indexOf("carousel"),
                                    w = -1 != d.name.toLowerCase().indexOf("crossfad");
                                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];
                                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, -1 != d.name.toLowerCase().indexOf("mirror") && 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"
                                        }), !0 === w || "slide" == d.transition.type || !0 === v ? (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 && (void 0 === f.transitions.nextSlide.data.$background || void 0 !== f.transitions.nextSlide.data.$background && (-1 != f.transitions.nextSlide.data.$background.attr("src").toLowerCase().indexOf("png") || 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) && -1 == d.name.toLowerCase().indexOf("mirror")) {
                                        var na = 0;
                                        0 !== ja && (na = -ja), ma.x = ba, ma.y = aa, ma.rotation = na, ma.scale = this.scale2D, ma.opacity = ca
                                    }
                                    void 0 !== 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, void 0 !== f.transitions.curSlide.data.$background && (H = f.transitions.curSlide.data.$background.data(f.defaults.init.dataKey), "3d" === b || "2d" === b && (!0 === w || "slide" === d.transition.type || !0 === v) ? 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 && (!0 === w || "slide" === d.transition.type || !0 === v) ? B.css("background-color", f.transitions.curSlide.data.backgroundColor) : 0 === this.$curTiles.children().length && this.$curTiles.css("background-color", f.transitions.curSlide.data.backgroundColor)), void 0 !== 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) {
                            a.data(f.defaults.init.dataKey).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"),
                                        n = function(a) {
                                            b.add(a, i - a.duration() * a.progress())
                                        };
                                    a().add(j).add(k).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() {
                                        a(this).data(f.defaults.init.dataKey).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), -1 !== f.slides[j].data.duration && 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()), -1 === f.slides[j].data.duration ? (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), !0 === f.transitions.layers.timeline.shouldRestart && 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.playByScrollStart) || !f.o.startInViewport) && (f.slider.isPopup && f.slider.state.popupIsVisible || !f.slider.isPopup) && (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 (-1 !== c.indexOf("*") && (l = "*"), -1 !== c.indexOf("/") && (l = "/"), -1 !== c.indexOf("+") && (l = "+"), -1 !== c.indexOf("-") && (l = "-"), l)
                                if (k = c.split(l), h = a.trim(k[0]), j = parseInt(a.trim(k[1])), g[h] && -1 !== g[d][1].indexOf(g[h][0]))
                                    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), -1 === g[d][1].indexOf(g[h][0]) && f.debug.add("warn", "layerTransition.timing3", [h, g[h], d, g[d]])), ("+" === l || e) && (m = j / 1e3);
                            else h = a.trim(c), g[h] && -1 !== g[d][1].indexOf(g[h][0]) ? m = e ? 0 : "number" == typeof b.timeline[h] ? b.timeline[h] : b.timeline[h](b) : f.debugMode && (g[h] ? -1 === g[d][1].indexOf(g[h][0]) && 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 = -1 !== k.loop.count && 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), -1 !== k.loop.repeat && ("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 && (void 0 === 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 && (void 0 === 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 && void 0 !== 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;
                                a.indexOf(f.slides.current.index) === 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) {
                                0 === f.slideshow.sequence.normalized.indexOf(f.slides.current.index) ? (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 = void 0 !== e.rotation ? 2 * e.rotation : void 0 !== 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() {
                            a().add(this.wrappers.cursor.$2d).add(this.wrappers.cursor.$3d).add(this.wrappers.scroll.$2d).add(this.wrappers.scroll.$3d).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() {
                            a().add(this.wrappers.cursor.$2d).add(this.wrappers.cursor.$3d).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 && !0 !== a.loop.yoyo && -1 !== a.loop.count && (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 (-1 !== window._layerSlider.pluginsBeingLoaded.indexOf(c)) return void f.plugins.checkLoaded(c); - 1 === window._layerSlider.pluginsLoaded.indexOf(c) && -1 === window._layerSlider.pluginsNotLoaded.indexOf(c) ? (window._layerSlider.pluginsBeingLoaded.push(c), a.ajax({
                                url: -1 === b.js.indexOf("http://") && -1 === b.js.indexOf("https://") ? (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] || -1 !== window._layerSlider.pluginsNotLoaded.indexOf(c) ? 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="' + (-1 === d.css.indexOf("http://") && -1 === d.css.indexOf("https://") ? (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() {
                        -1 === window._layerSlider.pluginsLoaded.indexOf(a) && -1 === window._layerSlider.pluginsNotLoaded.indexOf(a) || -1 !== window._layerSlider.pluginsBeingLoaded.indexOf(a) || (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() {
                    if (!document.body.contains(b)) return !1;
                    f.api.hasEvent("sliderWillLoad") && c.triggerHandler("sliderWillLoad"), 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 && !0 !== f.o.hideWelcomeMessage && !0 !== window._layerSlider.hideWelcomeMessage) {
                            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"
                        }; - 1 !== document.location.hash.indexOf("debug") && window.console && (-1 !== document.location.hash.indexOf("url=") && (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, 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 = -1 == f.o.width.indexOf("%") ? parseInt(f.o.width) : f.o.width : h.width ? j = -1 == h.width.indexOf("%") ? 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 = -1 == f.o.height.indexOf("%") ? parseInt(f.o.height) : f.o.height : h.height ? k = -1 == h.height.indexOf("%") ? 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 ? -1 === h.maxWidth.indexOf("%") ? parseInt(h.maxWidth) : h.maxWidth : 0, void 0 === f.userInitOptions.type && (u > 0 && v > 0 || "100%" === j && "100%" === k ? A = "fullsize" : u <= 0 && v <= 0 && f.o.responsiveUnder <= 0 ? A = void 0 !== f.o.responsive && !1 === f.o.responsive ? "fixedsize" : "responsive" : f.o.responsiveUnder > 0 && (A = "fullwidth")), A) {
                            case "responsive":
                                f.o.responsiveUnder = -1, -1 !== j.indexOf("%") && (j = n, f.debugMode && f.debug.add("warn", "sliderInit.percWidth", [A, j, n])), -1 !== k.indexOf("%") && (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":
                                -1 !== j.indexOf("%") && (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)), -1 !== k.indexOf("%") && (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":
                                -1 !== j.indexOf("%") && (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])), -1 !== k.indexOf("%") && (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]))
                        }
                        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), E = b.style.marginRight, "auto" === E ? C = "auto" : "" === E ? C = parseInt(i.getPropertyValue("margin-right")) : C = parseInt(b.style.marginRight), 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), !0 === f.o.hideOnMobile && 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 && !1 === f.o.globalBGImage && 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 && -1 != a("html").find('script[src*="layerslider"]').attr("src").indexOf("?") && (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 && !1 !== f.o.hideOnMobile || (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() {
                    if (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) return void f.api.methods("destroy");
                    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 (-1 !== g[k].indexOf("slider")) {
                                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()
                                } - 1 !== e[k].indexOf("%") ? h += k < 2 && c && d ? j / (100 / parseInt(e[k])) + "px " : e[k] + " " : h += 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(), -1 !== a.indexOf("swing") || -1 !== a.indexOf("linear") ? c = g.Linear.easeNone : (d = a.match(/(easeinout|easein|easeout)(.+)/)[2], e = g[d.charAt(0).toUpperCase() + d.slice(1)], -1 !== a.indexOf("easeinout") ? c = e.easeInOut : -1 !== a.indexOf("easeout") ? c = b ? e.easeIn : e.easeOut : -1 !== a.indexOf("easein") && (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), void 0 === c && (c = "easeInOutQuart"), g.ease = f.functions.convert.easing(c), g
                    },
                    randomProperties: function(a, b) {
                        if (a && -1 !== a.indexOf("(") && -1 !== a.indexOf(",") && -1 !== a.indexOf(")")) {
                            var c = a.split("(")[1].split(")")[0].split(","),
                                d = 1;
                            return c[0] = parseFloat(c[0]), c[1] = parseFloat(c[1]), -1 !== b.indexOf("scale") && (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 && -1 !== b.indexOf(f.defaults.init.lsDataArraySplitChar)) {
                            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 ("auto" !== (g = window.getComputedStyle(d[i]).getPropertyValue(b))) {
                            if (-1 !== g.indexOf("px")) return f.slider.$parentWithNumericWidthValue = a(d[i]), a(d[i]); - 1 !== g.indexOf("%") && (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")
                },
                getALT: function(a) {
                    return !!a.attr("alt") && a.attr("alt")
                },
                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 (-1 !== f.device.scroll.keys.indexOf(a.keyCode)) return f.device.scroll.preventDefault(a), !1
                    }
                },
                removeSelection: function() {
                    window.getSelection ? window.getSelection().empty ? window.getSelection().empty() : window.getSelection().removeAllRanges && window.getSelection().removeAllRanges() : document.selection && document.selection.empty()
                },
                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"), f.device.removeSelection()
                    },
                    exit: function() {
                        f.functions.setStates(f.slider, {
                            inFullscreen: !1
                        }), f.resize.all(), a("body, html").removeClass("ls-fullscreen"), f.device.removeSelection()
                    },
                    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 "reset":
                            case "resetSlider":
                                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();
                                        f.api.hasEvent("sliderDidRemove") && c.triggerHandler("sliderDidRemove"), c.remove()
                                    }
                                    window._layerSlider.removeSlider(e)
                                } else f.functions.setStates(f.slider, {
                                    shouldBeDestroyed: !0,
                                    sholudBeRemoved: b || !1
                                })
                        }
                },
                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,
                                deeplink: f.slides.get.deeplink(f.slides.first.index)
                            },
                            prev: {
                                index: f.slides.prev.index,
                                deeplink: f.slides.get.deeplink(f.slides.prev.index)
                            },
                            current: {
                                index: f.slides.current.index || f.slides.first.index,
                                deeplink: f.slides.get.deeplink(f.slides.current.index),
                                layersIn: f.layers.get("current,in"),
                                layersOut: f.layers.get("current,out"),
                                timeline: f.transitions._slideTimeline
                            },
                            next: {
                                index: f.slides.next.index,
                                deeplink: f.slides.get.deeplink(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: -1 !== document.location.href.indexOf("file://"),
                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 || void 0 !== b[0].style[f[h]];
                    for (var i = g.length - 1; i >= 0; i--) b.css("transform-style", "preserve-3d"), 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: -1 !== navigator.userAgent.indexOf("rident/5")
            }, f.initializedPlugins = {}, f.timeouts = {}, f.intervals = {}, f.debug = {
                options: {}
            }, f.plugin = {
                version: "6.4.0",
                releaseDate: "2017. 05. 02."
            }, f.slider.load()
        }
    }(jQuery);
                                    

Executed Writes (0)



HTTP Transactions (79)


Request Response
                                        
                                            GET / HTTP/1.1 
Host: trustweb.website
                                        
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

                                         
                                         204.93.177.101
HTTP/1.1 301 Moved Permanently
Content-Type: text/html; charset=UTF-8
                                        
X-Powered-By: PHP/5.6.31
Location: https://www.trustweb.website/
Content-Length: 0
Date: Wed, 13 Sep 2017 14:07:30 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: close


--- Additional Info ---
                                        
                                            POST / HTTP/1.1 
Host: ocsp.comodoca.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
Content-Length: 116
Content-Type: application/ocsp-request

                                         
                                         178.255.83.1
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Date: Wed, 13 Sep 2017 14:07:31 GMT
Server: Apache
Last-Modified: Mon, 11 Sep 2017 19:55:44 GMT
Expires: Mon, 18 Sep 2017 19:55:44 GMT
Etag: E8B91B370B8FC1D9E8C22A5E4F9E78F3EE3C4BDB
Cache-Control: max-age=452292,public,no-transform,must-revalidate
X-OCSP-Reponder-ID: rmdccaocsp15
Content-Length: 472
Connection: close


--- Additional Info ---
Magic:  data
Size:   472
Md5:    9eaab84739786b4a984863732d18c77e
Sha1:   e8b91b370b8fc1d9e8c22a5e4f9e78f3ee3c4bdb
Sha256: d0abbd6d226ada7a78aaf5f5c46051be7d514151d735f4e7f724d19b17369503
                                        
                                            POST / HTTP/1.1 
Host: ocsp.comodoca.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
Content-Length: 115
Content-Type: application/ocsp-request

                                         
                                         178.255.83.1
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Date: Wed, 13 Sep 2017 14:07:32 GMT
Server: Apache
Last-Modified: Mon, 11 Sep 2017 21:19:01 GMT
Expires: Mon, 18 Sep 2017 21:19:01 GMT
Etag: CF963197D7441CEFAD3AF60F278475ADFF210685
Cache-Control: max-age=457288,public,no-transform,must-revalidate
X-OCSP-Reponder-ID: rmdccaocsp18
Content-Length: 727
Connection: close


--- Additional Info ---
Magic:  data
Size:   727
Md5:    a25810009e6a5e9b4992ebb8c63d313d
Sha1:   cf963197d7441cefad3af60f278475adff210685
Sha256: ca3e25ed26f0e7f3b0247a2caed5713dfb6300e1cb1f15bd5a065416ccd853b1
                                        
                                            POST / HTTP/1.1 
Host: ocsp.usertrust.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
Content-Length: 115
Content-Type: application/ocsp-request

                                         
                                         178.255.83.1
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Date: Wed, 13 Sep 2017 14:07:32 GMT
Server: Apache
Last-Modified: Mon, 11 Sep 2017 21:19:01 GMT
Expires: Mon, 18 Sep 2017 21:19:01 GMT
Etag: EEF02773075AD2EE10CA267E7B58B87735BDD217
Cache-Control: max-age=457288,public,no-transform,must-revalidate
X-OCSP-Reponder-ID: rmdccaocsp18
Content-Length: 471
Connection: close


--- Additional Info ---
Magic:  data
Size:   471
Md5:    cd2b62d0bf526fea0bb88fd52c362091
Sha1:   eef02773075ad2ee10ca267e7b58b87735bdd217
Sha256: 410f6cc049eba5f23276a5ab276725d47973735c352f253e6406f6d5fce72cf0
                                        
                                            GET / HTTP/1.1 
Host: www.trustweb.website
                                        
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

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: text/html; charset=UTF-8
                                        
X-Powered-By: PHP/5.6.31
Link: <https://www.trustweb.website/wp-json/>; rel="https://api.w.org/", <https://www.trustweb.website/>; rel=shortlink
Transfer-Encoding: chunked
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:32 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: close


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   9510
Md5:    4712bf4b6235efacf01421db5d5935ce
Sha1:   6ccb9f4e0312866ed230d3a5cd81f8f4694b1e8e
Sha256: 4a2e2bd8e5f5a4d608309c94cacd07d682eefa49a7524015cd166a480b965fd7
                                        
                                            POST /ocsp HTTP/1.1 
Host: clients1.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
Content-Length: 107
Content-Type: application/ocsp-request

                                         
                                         216.58.211.142
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Date: Wed, 13 Sep 2017 14:07:33 GMT
Expires: Sun, 17 Sep 2017 14:07:33 GMT
Cache-Control: public, max-age=345600
Server: ocsp_responder
Content-Length: 463
X-XSS-Protection: 1; mode=block
X-Frame-Options: SAMEORIGIN


--- Additional Info ---
Magic:  data
Size:   463
Md5:    d5f6460f72b72dd0962a94ddd2f8e3bf
Sha1:   2b15aedce3db9dc9aea15fbcaf4be4f7de8c4640
Sha256: 18a057a6d2a8a4ef557ce4a4bcc074a918680c2053358e6b0836c1ef73116707
                                        
                                            POST / HTTP/1.1 
Host: g.symcd.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
Content-Length: 115
Content-Type: application/ocsp-request

                                         
                                         23.43.139.27
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Server: nginx/1.10.2
Content-Length: 1390
Content-Transfer-Encoding: binary
Cache-Control: max-age=472846, public, no-transform, must-revalidate
Last-Modified: Tue, 12 Sep 2017 01:23:19 GMT
Expires: Tue, 19 Sep 2017 01:23:19 GMT
Date: Wed, 13 Sep 2017 14:07:33 GMT
Connection: keep-alive


--- Additional Info ---
Magic:  data
Size:   1390
Md5:    775de2be162f21ece95211dfbf378ff2
Sha1:   5aa3f54491214e417e128fcc1b70119c2135565c
Sha256: 69abd56429cfa8fb3a69c040242457ab25397237c94b2f46ea2ce7b1848d55fe
                                        
                                            GET /css?family=Open+Sans|Lato 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.trustweb.website/

                                         
                                         64.233.162.95
HTTP/1.1 200 OK
Content-Type: text/css; charset=utf-8
                                        
Access-Control-Allow-Origin: *
Timing-Allow-Origin: *
Expires: Wed, 13 Sep 2017 14:07:33 GMT
Date: Wed, 13 Sep 2017 14:07:33 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="39,38,37,35"
Transfer-Encoding: chunked


--- Additional Info ---
Magic:  gzip compressed data, max compression
Size:   268
Md5:    e73eb31c1a42e4fe2731fed241593f5a
Sha1:   a09aeffa241af0f5eb06ab6b3911a531db5d8bb3
Sha256: bcab3fab0a47744b5839306563b2762e380a418007b4e32da2bafcaadb812ccb
                                        
                                            GET /wp-content/plugins/popup-maker/assets/css/site.min.css?ver=1.6.3 HTTP/1.1 
Host: www.trustweb.website
                                        
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.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:32 GMT
Last-Modified: Thu, 06 Jul 2017 02:49:24 GMT
Content-Length: 1076
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:32 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   1076
Md5:    952fb179b544c3d70232980a0a104d2a
Sha1:   6ae7512d7022063723c75822b6a12b307c258ffa
Sha256: bbdff72902afd279b228e3e81db3fb3cfa4d9c12cb2bea24fd315d99017d863b
                                        
                                            GET /wp-content/plugins/woocommerce/assets/css/woocommerce-layout.css?ver=3.0.6 HTTP/1.1 
Host: www.trustweb.website
                                        
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.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Thu, 11 May 2017 00:18:30 GMT
Content-Length: 2047
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   2047
Md5:    b1ad598e093071269a452255ed6d4bfa
Sha1:   62a7f16636fafcd72275e9dcf214ac7e4c62f8cc
Sha256: e263b08f10fbb9fa0149eb76f5b3e603dee1b72e626eee10f76b1257ee639a3b
                                        
                                            GET /wp-content/plugins/LayerSlider/static/layerslider/css/layerslider.css?ver=6.4.0 HTTP/1.1 
Host: www.trustweb.website
                                        
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.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Thu, 11 May 2017 00:13:22 GMT
Content-Length: 3792
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   3792
Md5:    4a0c5b657e887e6b853a9a0aaa92b363
Sha1:   9e5d7f70c13257bc04dac54653fb59df8887f1f8
Sha256: 1cf5607f3690f73f36810e3ece48c4befb803ab814fd102dffbb53d5027a55e6
                                        
                                            GET /wp-content/plugins/bbpress/templates/default/css/bbpress.css?ver=2.5.12-6148 HTTP/1.1 
Host: www.trustweb.website
                                        
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.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Thu, 11 May 2017 00:18:39 GMT
Content-Length: 5104
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   5104
Md5:    e1d84eafd673b05c623311af7d26c40b
Sha1:   9b358fc44f1777bd89276cf948076c13ba2cb366
Sha256: a5588f945764bb75ac00e3476cdecbe7b93a03af96ceab959eb2ef3c7cc038f9
                                        
                                            GET /wp-content/plugins/woocommerce/assets/css/woocommerce-smallscreen.css?ver=3.0.6 HTTP/1.1 
Host: www.trustweb.website
                                        
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.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Thu, 11 May 2017 00:18:30 GMT
Content-Length: 1073
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   1073
Md5:    07c15e8c369706548e07ec8080c837e4
Sha1:   d2be5bdc8fd1f3e8be4ddf96dc1a9b9c34dd0f20
Sha256: b682757c3bb9e3310983d4b62bda89371cb01d00da16166421cfc0a263cd9e35
                                        
                                            GET /?mcsf_action=main_css&ver=4.7.5 HTTP/1.1 
Host: www.trustweb.website
                                        
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.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: text/css;charset=UTF-8
                                        
X-Powered-By: PHP/5.6.31
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Content-Length: 363
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   363
Md5:    a0a9ffafd59f30744ea5d857fc1428cc
Sha1:   caa11d107747119a78b7138f33583e3c50c7260e
Sha256: ed7bd8c11d903592d4ab99bbe43fcd128e5e8ca06c97f87946832f184f63594b
                                        
                                            GET /wp-content/plugins/karma_builder/css/karma-builder.css?ver=4.7.5 HTTP/1.1 
Host: www.trustweb.website
                                        
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.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Thu, 11 May 2017 00:13:08 GMT
Content-Length: 17029
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   17029
Md5:    7e00368a568e21a1c920efd59823d406
Sha1:   6653113240bdfdd3d4eb7c92aad19a7801425310
Sha256: 382cb57ee583b1dff00ab15e39dee13e2843620d8de4684879a8ba34d29f4044
                                        
                                            GET /wp-content/plugins/woocommerce/assets/css/woocommerce.css?ver=3.0.6 HTTP/1.1 
Host: www.trustweb.website
                                        
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.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Thu, 11 May 2017 00:18:30 GMT
Content-Length: 8323
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   8323
Md5:    e46a90ec5d1622be477a4b58bba40c86
Sha1:   be8ceb99d455c6e7d7cf133afeaf601ce0d00805
Sha256: feba3e9e8e0ecc7596014b38bf4f80d230901d31c00714dd030e59157bdfe677
                                        
                                            GET /wp-content/themes/karma/css/karma-sky-blue.css?ver=4.7.5 HTTP/1.1 
Host: www.trustweb.website
                                        
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.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Mon, 09 Jan 2017 16:18:06 GMT
Content-Length: 3257
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   3257
Md5:    a0ed431e4c0ea122f19332d2d7d1d4e9
Sha1:   4ae793de9fad7c6884ac80e20542c0ebdc8e59ce
Sha256: 0f93552c847014ed2aa667948eb90c5932798802c2e8b1ffda1c381e8043f956
                                        
                                            GET /wp-content/plugins/js_composer/assets/lib/bower/font-awesome/css/font-awesome.min.css?ver=5.1.1 HTTP/1.1 
Host: www.trustweb.website
                                        
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.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Mon, 01 May 2017 11:41:14 GMT
Content-Length: 6679
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   6679
Md5:    0c13febb4797aa227893d0411b955bbb
Sha1:   39952294b48c135f061921737435ecef1a9662b8
Sha256: 5757744ff68cf2fd19b8a350155a0bf4a5ec9c3515ade1ccd1332ca4a85065ab
                                        
                                            GET /wp-content/themes/karma/css/_woocommerce.css?ver=4.7.5 HTTP/1.1 
Host: www.trustweb.website
                                        
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.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Mon, 09 Jan 2017 16:18:30 GMT
Content-Length: 1586
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   1586
Md5:    9cc4147ee48fa83d8c8264dc179133d7
Sha1:   b4b4b8d2e4b4ea1b3ead54fe71d0dbf6913b489e
Sha256: b2717d9dcf4965da033795ebbd132df278c45b1f98e9fa3eaa63e77556266913
                                        
                                            GET /wp-content/themes/karma/css/_mobile.css?ver=4.7.5 HTTP/1.1 
Host: www.trustweb.website
                                        
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.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Wed, 18 Jan 2017 02:36:14 GMT
Content-Length: 9478
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   9478
Md5:    8de840559e9c8e360b5fafb0fc4068f8
Sha1:   8f746a5c2bb0b3d6393c013acf7945a47537af48
Sha256: 1d3c3704820e5c10352898b5f646f818cdaf32c0d30e5ea9d184bdf37d8f0a34
                                        
                                            GET /wp-content/plugins/gravityforms/css/formreset.min.css?ver=2.2 HTTP/1.1 
Host: www.trustweb.website
                                        
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.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Tue, 09 May 2017 22:22:19 GMT
Content-Length: 399
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   399
Md5:    c89e67899db611a05cd0159d633f08b4
Sha1:   d31dacd79a2d9a7f138c288c5b14de250a2b02fb
Sha256: 3019890bd28a9216186293b0b65542886a4670fd7f634477988e71a2fa7b369a
                                        
                                            GET /wp-content/plugins/gravityforms/css/formsmain.min.css?ver=2.2 HTTP/1.1 
Host: www.trustweb.website
                                        
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.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Tue, 09 May 2017 22:22:19 GMT
Content-Length: 10778
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   10778
Md5:    92aafe5e77383e1bf94c1217a9be23a3
Sha1:   e65dede436bc89de5721b0f1bab3c965e82974d4
Sha256: cc33be61fb5b740d920075e31e482e39ba15a73252038743311c0e66ce6ebcbd
                                        
                                            GET /wp-content/plugins/js_composer/assets/css/js_composer.min.css?ver=5.1.1 HTTP/1.1 
Host: www.trustweb.website
                                        
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.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Mon, 01 May 2017 11:41:14 GMT
Content-Length: 44321
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   44321
Md5:    44fad29667c66ec0866e5ae7c32e79de
Sha1:   581e6afcd9ece8ee55b158461002c282565360aa
Sha256: 3f121c00e86a9e87ed48b31592cde716f2928a976267ea78c68f51dc4bd25870
                                        
                                            GET /wp-content/plugins/gravityforms/css/readyclass.min.css?ver=2.2 HTTP/1.1 
Host: www.trustweb.website
                                        
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.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Tue, 09 May 2017 22:22:19 GMT
Content-Length: 3468
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   3468
Md5:    bd74b7e8e02adab630b1a14e8cce892b
Sha1:   a44e65ee619dfd5a631d5d333a8efa2bb138f6e3
Sha256: e764add9b9378e54bec453431262755306b157311aacffc96387c4e67dd416fd
                                        
                                            GET /wp-content/themes/karma/style.css?ver=4.7.5 HTTP/1.1 
Host: www.trustweb.website
                                        
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.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Mon, 06 Feb 2017 14:27:24 GMT
Content-Length: 40701
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   40701
Md5:    a598d7aa72a9994125290de099ef1182
Sha1:   d8249bd65ab2f245363d561613f2e3c50c30ab60
Sha256: a9262a8942ed63aca467ef37ea977885dc4dd4d1345f5b6e326539b8fd5e0035
                                        
                                            GET /wp-content/plugins/gravityforms/css/browsers.min.css?ver=2.2 HTTP/1.1 
Host: www.trustweb.website
                                        
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.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Tue, 09 May 2017 22:22:19 GMT
Content-Length: 1186
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   1186
Md5:    d121ecf8eef0083444e7339de6726d0a
Sha1:   3d155e885720632c99ad942ca255173731ec19d0
Sha256: 4ba190d397fc679105e12b83497b6ab2ed86c8b0e607611ad4b3fe8849251521
                                        
                                            GET /wp-includes/js/jquery/jquery-migrate.min.js?ver=1.4.1 HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Fri, 20 May 2016 16:41:28 GMT
Content-Length: 4014
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
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.4.0 HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Thu, 11 May 2017 00:13:22 GMT
Content-Length: 3396
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   3396
Md5:    eb670015b0b1f37defff4ffcf890f043
Sha1:   efbc16d930be1673c69a33063f6e0ce1c1938d5a
Sha256: 5b14e2fb3079ca42ea5d465dfd942a4944c4e0df08d4d0e14abc0f9e90b362da
                                        
                                            GET /wp-content/plugins/woocommerce/assets/js/frontend/add-to-cart.min.js?ver=3.0.6 HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Thu, 11 May 2017 00:18:30 GMT
Content-Length: 803
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   803
Md5:    6e620002b04c4064989dabc0a9cbfdec
Sha1:   5c3a2da9039cb9201fea1c347f9b55ea75d53542
Sha256: de3edc0904e7f846d501ada94f78e0fbd7fa89813072e50a9083072419b5df6e
                                        
                                            GET /wp-content/plugins/LayerSlider/static/layerslider/js/greensock.js?ver=1.19.0 HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Thu, 11 May 2017 00:13:22 GMT
Content-Length: 39581
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   39581
Md5:    b3b414cd312de18cb3c79cec0715237b
Sha1:   b6b022501cb9f8f284513f2549801560ca3c183f
Sha256: e44c9eb5127cc6cd897b2d4b144026b473635953aa8c2a60c25b75a8e6589877
                                        
                                            GET /wp-content/plugins/js_composer/assets/js/vendors/woocommerce-add-to-cart.js?ver=5.1.1 HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Mon, 01 May 2017 11:41:14 GMT
Content-Length: 351
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   351
Md5:    caa6ca5d23d1adf35e63b219631fff8e
Sha1:   786acb0cf5a9033939c4c4b8f5c4109e2e15401f
Sha256: 50973c0a98e9463c4417b2ccd9424a5f89a9924b80878548f19422b25d23d901
                                        
                                            GET /wp-includes/js/jquery/jquery.js?ver=1.12.4 HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Mon, 23 May 2016 19:30:30 GMT
Content-Length: 33799
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   33799
Md5:    252047cc64c4b1980fafe6abca669f06
Sha1:   912b757d6d268e5e94f09581c5dec4d72c64b219
Sha256: 1045d98023671ce42bbcb900f609fe49c335479963cdfab1f1824f1db18892dc
                                        
                                            GET /wp-content/plugins/gravityforms/js/jquery.json.min.js?ver=2.2 HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Tue, 09 May 2017 22:22:23 GMT
Content-Length: 943
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   943
Md5:    25b54549f93b4f56b3a3f38c69e32937
Sha1:   918802e8b1ce30abb146004c4f5bb8c4a3c40f2e
Sha256: 6c9fbd34f72beb886a78dcde8e07862a91ce9ba6291c26cc7d7882567153ae11
                                        
                                            GET /wp-content/plugins/gravityforms/js/gravityforms.min.js?ver=2.2 HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Tue, 09 May 2017 22:22:23 GMT
Content-Length: 8343
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   8343
Md5:    dd5c090ca990606ba81620e87c4441f7
Sha1:   818186774ad93cd1a31d079d6a68c70c8aa0aa66
Sha256: c57fd95f70271d50abfa31d68595376737a35289a201834e352c6279b044bbe6
                                        
                                            GET /wp-content/plugins/gravityforms/js/placeholders.jquery.min.js?ver=2.2 HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Tue, 09 May 2017 22:22:23 GMT
Content-Length: 1750
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   1750
Md5:    4367943533a0b07a27290634c64da5eb
Sha1:   e903434a1e2c572e93c59fca5603869fecbe94e7
Sha256: e261f0592109e7a4a12cfe2e6753990a1ae69db3cf8f3a2563cec4b3d99b284d
                                        
                                            GET /wp-content/plugins/bbpress/templates/default/js/editor.js?ver=2.5.12-6148 HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Thu, 11 May 2017 00:18:39 GMT
Content-Length: 476
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   476
Md5:    06943e0b1ffde0aa2ca8843cb3cb0c82
Sha1:   62a47b268531a700863dfe9f5d0b10c7dfe4eeb8
Sha256: 973fa462adc13e6c42379119a220ad5fb9b74b577c20e8d7f78acc1ee6fbcfd0
                                        
                                            GET /wp-content/plugins/LayerSlider/static/layerslider/js/layerslider.kreaturamedia.jquery.js?ver=6.4.0 HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Thu, 11 May 2017 00:13:22 GMT
Content-Length: 42610
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   42610
Md5:    aacdd17e72d3c0f051dc072072ad554f
Sha1:   d9a857c305b61bd120241b034cc07a101ac4d83d
Sha256: b69c7964a2e5cf87b5c19ee70864eb9b115c374225479436f2735168e6e3fcc5
                                        
                                            GET /wp-content/plugins/karma_builder/js/appear.min.js HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Thu, 11 May 2017 00:13:08 GMT
Content-Length: 833
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   833
Md5:    2e8f70d99f4bee7d5ee391529e00ac4a
Sha1:   592b7341592ac233b723128092182267c7dcf4d7
Sha256: e8be00ce86d2ce40fc69b7d9fe2fc562da9e8e1b5cf2a6046b17494cfa447dd3
                                        
                                            GET /wp-content/plugins/karma_builder/js/bootstrap.min.js HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Thu, 11 May 2017 00:13:08 GMT
Content-Length: 7287
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   7287
Md5:    23996f2442668a6ebc7efbec1e02d1a6
Sha1:   380158e7487ce0dbe86cd07a71c232f84f515bac
Sha256: fdc47dba645a7f0e1f93d93cbf3fc7fb950ee5d5ad94bd1249b888388aa74b36
                                        
                                            GET /wp-content/plugins/js_composer/assets/lib/waypoints/waypoints.min.js?ver=5.1.1 HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Mon, 01 May 2017 11:41:14 GMT
Content-Length: 2615
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   2615
Md5:    ce37923565b26522f8e8cbd5070f03a1
Sha1:   139bdb311e96f326a2a7040e012a32bfa5331251
Sha256: 2c3ab394646b898c62e876a367ca8ac8dd9a81ff46559d3e4765487b7125b0d3
                                        
                                            GET /wp-content/plugins/karma_builder/js/easy-pie-chart.min.js HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:33 GMT
Last-Modified: Thu, 11 May 2017 00:13:08 GMT
Content-Length: 1634
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:33 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   1634
Md5:    5e696998f835e8107b25a5c2623f42de
Sha1:   e3941a0f1cb5767d7e0a1c04e55f061aa9d0b43b
Sha256: 0f2e2c076c3fcf70368ff18ac9be503917613e1c0847e49c284ba842f144ec96
                                        
                                            GET /wp-content/plugins/karma_builder/js/karma-builder.js HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:34 GMT
Last-Modified: Thu, 11 May 2017 00:13:09 GMT
Content-Length: 4553
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:34 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   4553
Md5:    ea5e57e397f81929b43add24d71719a7
Sha1:   9cce55868683ec46a72f30d30cd08d6e6757ac3f
Sha256: f949a3d98c408318af9565f700acc2d1b677af10c120ec59213072f77405f979
                                        
                                            GET /wp-content/plugins/woocommerce/assets/js/js-cookie/js.cookie.min.js?ver=2.1.4 HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:34 GMT
Last-Modified: Thu, 11 May 2017 00:18:30 GMT
Content-Length: 987
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:34 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   987
Md5:    7007dfadc2510da35f253a2125c0ace6
Sha1:   a2db43fd7c61035c870c22cf6a76e046d2bf096f
Sha256: 5a08c4fc9fdc7194a8502962b724260c0c03cf9a5d212c2d9125a6560b195b97
                                        
                                            GET /wp-content/plugins/woocommerce/assets/js/jquery-blockui/jquery.blockUI.min.js?ver=2.70 HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:34 GMT
Last-Modified: Thu, 11 May 2017 00:18:30 GMT
Content-Length: 3547
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:34 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   3547
Md5:    5248acf7cf3704804f9272b40b533a3f
Sha1:   957f32755baba09f836961a87114a9791bac1d15
Sha256: 685837f234472a5034bd9ba83131b04c7dce8f8e75587cd1cafeb4b33e4171a1
                                        
                                            GET /wp-content/plugins/woocommerce/assets/js/frontend/woocommerce.min.js?ver=3.0.6 HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:34 GMT
Last-Modified: Thu, 11 May 2017 00:18:30 GMT
Content-Length: 291
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:34 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   291
Md5:    ac124f82aed8dc7e5f1c57a66209c308
Sha1:   24a3a1cb2ecbbabfaf8f41718ec686412fe721f1
Sha256: a3c65bc735be63e78a9039a4a5d2360d9dc287e1259f2466639dfbfb785a2923
                                        
                                            GET /wp-content/plugins/woocommerce/assets/js/frontend/cart-fragments.min.js?ver=3.0.6 HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:34 GMT
Last-Modified: Thu, 11 May 2017 00:18:30 GMT
Content-Length: 925
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:34 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   925
Md5:    29e16fda3e51c17a7c4f3850533e55a9
Sha1:   55bbc237e708e3bcd9dff176a3ab449aa5879a8c
Sha256: 8ba6dce5d535772b57ecd97065a74528f703ff5a98144410f5477f4e77560888
                                        
                                            GET /wp-content/themes/karma/js/custom-main.js HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:34 GMT
Last-Modified: Thu, 02 Feb 2017 20:15:33 GMT
Content-Length: 7564
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:34 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   7564
Md5:    8839a03d826d210abf108ce73c754212
Sha1:   deda31b42543f95ee74639157b04fba54e15eda3
Sha256: ea38ef6de7b7d33bca60c234a88cc19581457b1788cba33886f7b130cb58cbcf
                                        
                                            GET /wp-content/themes/karma/js/superfish.js HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:34 GMT
Last-Modified: Mon, 09 Jan 2017 16:27:30 GMT
Content-Length: 2538
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:34 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   2538
Md5:    9fe8058a458a64667fbff0889978fd31
Sha1:   580cc642851e2c567cb105178edb5377da7c0f0a
Sha256: 311d14a4a16c15b096f0444f4bb6c50c64021c19ed9785ecd86405c476e80da2
                                        
                                            GET /wp-content/themes/karma/js/jquery.fitvids.js HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:34 GMT
Last-Modified: Mon, 06 Feb 2017 15:28:41 GMT
Content-Length: 1341
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:34 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   1341
Md5:    1ac5fd0d746d90e81bb4663d18a6d4c8
Sha1:   4566f66fbfc4cd3881967b31c39ba9299c5f4e6a
Sha256: 9e76b39ba632c5e8d0e3e91427ba4498cb4343394efbfb60fcc58dd0e8a09d3f
                                        
                                            GET /wp-content/themes/karma/js/jquery.flexslider.js HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:34 GMT
Last-Modified: Tue, 17 Jan 2017 22:44:06 GMT
Content-Length: 7324
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:34 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   7324
Md5:    2800dea21de9518c4a816741d4534244
Sha1:   a91e832f78471089ea6c980802ca51fb126f3afc
Sha256: 62e2f2c6c74e84aea39521226a0571a2831cd47fc447d44b44257ed1dfaf6f0b
                                        
                                            GET /wp-content/themes/karma/js/retina.js HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:34 GMT
Last-Modified: Mon, 09 Jan 2017 16:27:30 GMT
Content-Length: 1262
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:34 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   1262
Md5:    98365895394eadd3fb7244d2f76452fb
Sha1:   9d7a8b5175e11da999901753e107781f46e99fb8
Sha256: 21f053105f7575cd0bcf4734fc3680919c6de8b96784eb5938a842a6fd194c98
                                        
                                            GET /wp-content/plugins/js_composer/assets/lib/bower/isotope/dist/isotope.pkgd.min.js?ver=5.1.1 HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:34 GMT
Last-Modified: Mon, 01 May 2017 11:41:14 GMT
Content-Length: 9714
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:34 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   9714
Md5:    cf3eb56c5957c515253330171ab9170e
Sha1:   a30bb72e47a436c36e9b1b30a62962d8d5784ea3
Sha256: c581a9b40db6cfd590d89dbee52c6f39b9fc1186b93c609b30852eada91e0547
                                        
                                            GET /wp-includes/js/jquery/ui/core.min.js?ver=1.11.4 HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:34 GMT
Last-Modified: Thu, 03 Nov 2016 16:10:34 GMT
Content-Length: 1821
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:34 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   1821
Md5:    4664a831e60a807962a0341122693831
Sha1:   0c582fa939884d543af617c2bad977157f8c319b
Sha256: f1320f1c4d030cd930d721d93ea112dc789295f06afc8a3381c922a92b077f0d
                                        
                                            GET /wp-includes/js/jquery/ui/widget.min.js?ver=1.11.4 HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:34 GMT
Last-Modified: Thu, 03 Nov 2016 16:10:34 GMT
Content-Length: 2599
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:34 GMT
Accept-Ranges: bytes
Server: LiteSpeed
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/tabs.min.js?ver=1.11.4 HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:34 GMT
Last-Modified: Thu, 03 Nov 2016 16:10:34 GMT
Content-Length: 3889
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:34 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   3889
Md5:    016344e82da329adfd24d5a148a9f8f3
Sha1:   6ed93d2e32cfe59ccee9687f1dc1c973084dc73f
Sha256: 32dc14ed8c3233e678c47b93b57e1fc159a0f19b0735bdf4af31ade5739e59ab
                                        
                                            GET /wp-includes/js/jquery/ui/position.min.js?ver=1.11.4 HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:34 GMT
Last-Modified: Thu, 03 Nov 2016 16:10:34 GMT
Content-Length: 2562
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:34 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   2562
Md5:    820683f34f24b91904907c620a2fb928
Sha1:   b35cc2bff48a376281feaf0c8c259b45f32e286c
Sha256: d2e02cbefd97ff4e104c66ed951bf999b9d6166723cbdb112940605eb0a73de8
                                        
                                            GET /wp-includes/js/jquery/ui/accordion.min.js?ver=1.11.4 HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:34 GMT
Last-Modified: Thu, 03 Nov 2016 16:10:34 GMT
Content-Length: 2707
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:34 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   2707
Md5:    487c49117b56742c222364c662b35650
Sha1:   66184692354c96d0bfd22dd0291d235b5b5ca89c
Sha256: b88beebf89515edfc9c2e509eb3c902dad05205d102566ed4a543b9cecf81849
                                        
                                            GET /wp-content/themes/karma/js/jquery.prettyPhoto.js HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:34 GMT
Last-Modified: Mon, 09 Jan 2017 16:27:32 GMT
Content-Length: 5948
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:34 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   5948
Md5:    424a4bd419200bf96f5ed9bd5b1f5753
Sha1:   f08e4125a62e93141d0317f18bdc900aa55d69f7
Sha256: f6bd715a91acecbeba0f3ebae10a4eab63f9d548da45567ebdead8e077890779
                                        
                                            GET /wp-content/plugins/popup-maker/assets/js/site.min.js?defer&ver=1.6.3 HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:34 GMT
Last-Modified: Thu, 06 Jul 2017 02:49:24 GMT
Content-Length: 11224
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:34 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   11224
Md5:    03ab50ab6f81198c8626f339fbc36220
Sha1:   6a3475f802a8fbb66026ab410b315f9c13c22926
Sha256: e1312b483c28e59344a9bfa9f48de3cb39e397a0f81c399def4a1700c8086199
                                        
                                            GET /css?family=Acme|Montserrat 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.trustweb.website/

                                         
                                         64.233.162.95
HTTP/1.1 200 OK
Content-Type: text/css; charset=utf-8
                                        
Access-Control-Allow-Origin: *
Timing-Allow-Origin: *
Expires: Wed, 13 Sep 2017 14:07:34 GMT
Date: Wed, 13 Sep 2017 14:07:34 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="39,38,37,35"
Transfer-Encoding: chunked


--- Additional Info ---
Magic:  gzip compressed data, max compression
Size:   266
Md5:    5318acb902a66f502e9c71c4dbfc5197
Sha1:   6da54232f5196959bd3642f50608dff9b812782f
Sha256: 6961bb0850e6a4ffa57fa84d383c5a0143a582a0441c20a67dcbe47bc9767673
                                        
                                            GET /wp-includes/js/wp-embed.min.js?ver=4.7.5 HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:34 GMT
Last-Modified: Thu, 24 Nov 2016 01:08:34 GMT
Content-Length: 751
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:34 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   751
Md5:    7542039ce963ffd18ad4fb7be13bd2be
Sha1:   8385e433e8e65739fc27b6bd16b1a7ae71b11084
Sha256: a70bca1336a4ac7592ce631cbb22c9ebb01d60461d221ac7a46f91a4ccfd1255
                                        
                                            GET /wp-content/plugins/js_composer/assets/js/dist/js_composer_front.min.js?ver=5.1.1 HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:34 GMT
Last-Modified: Mon, 01 May 2017 11:41:14 GMT
Content-Length: 5521
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:34 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   5521
Md5:    c44a32c4e67a74f95c4d047b6a1ee8ee
Sha1:   cb2e6e08c4a684cd8ca34f78d21de3af280f1665
Sha256: 8f3a49d93c398382c78e26cbccbbc21cf6b6c8a68d29c23c69bbdcffc18dbea2
                                        
                                            GET /wp-content/uploads/2017/07/logo.jpg HTTP/1.1 
Host: www.trustweb.website
                                        
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.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: image/jpeg
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:34 GMT
Last-Modified: Thu, 20 Jul 2017 23:42:21 GMT
Content-Length: 7457
Date: Wed, 13 Sep 2017 14:07:34 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  JPEG image data, JFIF standard 1.01
Size:   7457
Md5:    e55762149e2bc2710946ea1e9f91b581
Sha1:   6cafc61c91da600f631e64702adc97f2816397bb
Sha256: 581f1d13ca8749210613ddf3b1e4c8a4bbc6a0d019f9ad50c4c639816354c271
                                        
                                            GET /wp-content/uploads/2017/07/mail_gmail.png HTTP/1.1 
Host: www.trustweb.website
                                        
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.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: image/png
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:34 GMT
Last-Modified: Thu, 06 Jul 2017 05:55:28 GMT
Content-Length: 1528
Date: Wed, 13 Sep 2017 14:07:34 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  PNG image, 32 x 26, 8-bit/color RGBA, non-interlaced
Size:   1528
Md5:    5d2f329d5813e9ad215d0117610a58c5
Sha1:   dc79b83740707c383ee1eff430223a9d5ea6ff2d
Sha256: 0e95cbf733f41b43a1e2716643ad7ea8cd5fdfcb2eee2d038f4618c579bcaff7
                                        
                                            GET /wp-content/themes/karma/js/scrollWatch.js HTTP/1.1 
Host: www.trustweb.website
                                        
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: https://www.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:34 GMT
Last-Modified: Mon, 09 Jan 2017 16:27:30 GMT
Content-Length: 1546
Content-Encoding: gzip
Vary: Accept-Encoding
Date: Wed, 13 Sep 2017 14:07:34 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   1546
Md5:    e7ff1a0f0b5ef5552c5846ec2a7c933b
Sha1:   35ccaf2d8cbd8d1ceb61479a804049c188caf669
Sha256: e0389c4a3843f7f8098e405cf4e661f41deb072846c440160b61f591de75962e
                                        
                                            POST /ocsp HTTP/1.1 
Host: clients1.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
Content-Length: 107
Content-Type: application/ocsp-request

                                         
                                         216.58.211.142
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Date: Wed, 13 Sep 2017 14:07:35 GMT
Expires: Sun, 17 Sep 2017 14:07:35 GMT
Cache-Control: public, max-age=345600
Server: ocsp_responder
Content-Length: 463
X-XSS-Protection: 1; mode=block
X-Frame-Options: SAMEORIGIN


--- Additional Info ---
Magic:  data
Size:   463
Md5:    aafdacf266b76748b8a1624a2f0964f5
Sha1:   95d0011749bc14905a9ee761ccb86cec071b7052
Sha256: 1074ad37270361c6e223ac4200193bfc0cd30f899b234ae8631651598fbe1573
                                        
                                            GET /wp-content/uploads/2017/07/live_hotmail.png HTTP/1.1 
Host: www.trustweb.website
                                        
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.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: image/png
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:34 GMT
Last-Modified: Thu, 06 Jul 2017 06:00:40 GMT
Content-Length: 517
Date: Wed, 13 Sep 2017 14:07:34 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  PNG image, 32 x 32, 8-bit colormap, non-interlaced
Size:   517
Md5:    8dccdb0f930ec8ff6c62dd13474fa9f4
Sha1:   f8261ea396e36539b67a8a8ecb5290455f8f61af
Sha256: c7b07a0440ecfbd1f32110a6a5c7e92ecfe0200a65ba5fdd5660a98cf2294c09
                                        
                                            GET /wp-content/uploads/2017/07/office365.png HTTP/1.1 
Host: www.trustweb.website
                                        
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.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: image/png
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:34 GMT
Last-Modified: Thu, 06 Jul 2017 06:40:45 GMT
Content-Length: 51135
Date: Wed, 13 Sep 2017 14:07:34 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  PNG image, 32 x 26, 8-bit/color RGBA, non-interlaced
Size:   51135
Md5:    45766ddf6ec10cc0cf6aa0504cacfdff
Sha1:   08e6ffbbc0227e73513ede503274f0c6b7ce64d8
Sha256: cba57e0eadc5e55e4eaf56d23d9b2368fc7c90dfd22de3cb4254d7e9d902ea45
                                        
                                            GET /wp-content/uploads/2017/07/email.png HTTP/1.1 
Host: www.trustweb.website
                                        
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.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: image/png
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:34 GMT
Last-Modified: Thu, 06 Jul 2017 05:59:48 GMT
Content-Length: 2921
Date: Wed, 13 Sep 2017 14:07:34 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  PNG image, 32 x 32, 8-bit colormap, non-interlaced
Size:   2921
Md5:    f093ed003976ef8aa9d299051c06f26b
Sha1:   6072eb6be0da0dea159ce919c634e78fcefb7047
Sha256: 73b1ce58fa539aab1d6d1424607c5ff60fc5e2f2c0becd3a776f7f4f8f3664b0
                                        
                                            GET /wp-content/uploads/2017/07/aol.png HTTP/1.1 
Host: www.trustweb.website
                                        
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.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: image/png
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:34 GMT
Last-Modified: Thu, 06 Jul 2017 06:01:37 GMT
Content-Length: 1183
Date: Wed, 13 Sep 2017 14:07:34 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  PNG image, 32 x 32, 8-bit/color RGBA, non-interlaced
Size:   1183
Md5:    1db15cc5ad50540b10cde2d733efd2a4
Sha1:   3526d7089c8e1bca74d31b827ecd91d26c04deb9
Sha256: 1b5fe12e21a9d8ff78e007ecf9fa5a819947dc3e6ba7a0ca4951760d1c006adf
                                        
                                            GET /wp-content/uploads/2017/07/favicon.ico HTTP/1.1 
Host: www.trustweb.website
                                        
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

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: image/x-icon
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:34 GMT
Last-Modified: Thu, 06 Jul 2017 00:12:40 GMT
Content-Length: 6518
Date: Wed, 13 Sep 2017 14:07:34 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  MS Windows icon resource - 2 icons, 16x16, 256-colors
Size:   6518
Md5:    9391620020d44c78b0dc51abbcd151a0
Sha1:   8f22f15342a0c648631d2b3ea32cfdd9a26b4137
Sha256: a04c33d7c5aa98f3ba82edc2aa05c46c2af0c9c90d8617a92bca3a4f0fd3af8f

Alerts:
  urlquery:
    - Phishing website detected
                                        
                                            GET /wp-content/uploads/2017/07/yahoo.png HTTP/1.1 
Host: www.trustweb.website
                                        
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.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: image/png
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:34 GMT
Last-Modified: Thu, 06 Jul 2017 05:58:21 GMT
Content-Length: 2830
Date: Wed, 13 Sep 2017 14:07:34 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  PNG image, 32 x 32, 8-bit/color RGBA, non-interlaced
Size:   2830
Md5:    fda2a0cac8b16568eed32edbc85b5db8
Sha1:   c5783560af0df9ff43f1320645c773a7b58b7795
Sha256: 0b6c1e1b33c085efad5bdc32654ec90b4ddc934eb1c1aca71a439ff89867f468
                                        
                                            GET /wp-content/themes/karma/images/skins/bg-footer-bottom-sky-blue.png HTTP/1.1 
Host: www.trustweb.website
                                        
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.trustweb.website/wp-content/themes/karma/css/karma-sky-blue.css?ver=4.7.5

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: image/png
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:35 GMT
Last-Modified: Mon, 09 Jan 2017 16:24:22 GMT
Content-Length: 3579
Date: Wed, 13 Sep 2017 14:07:35 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  PNG image, 1300 x 89, 8-bit colormap, non-interlaced
Size:   3579
Md5:    ea32d736f1fbc9f79cb4f70dcee1ae8d
Sha1:   928f6e836fb4d150a36ccc8f4d4d58f7302411ea
Sha256: 784afdd13a2e17f05de62d2def0abe94252c9747c420ef9eb7129f49b63b7f27
                                        
                                            GET /wp-content/uploads/2017/07/signin.png HTTP/1.1 
Host: www.trustweb.website
                                        
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.trustweb.website/

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: image/png
                                        
Cache-Control: public, max-age=604800
Expires: Wed, 20 Sep 2017 14:07:35 GMT
Last-Modified: Thu, 06 Jul 2017 03:09:00 GMT
Content-Length: 49353
Date: Wed, 13 Sep 2017 14:07:35 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  PNG image, 76 x 34, 8-bit/color RGBA, non-interlaced
Size:   49353
Md5:    63ecf499c79444ccc1f6c4639c5720ed
Sha1:   587dbeb960dc5a8b0a444905e9ab8b3d6fa341df
Sha256: ed9a26a5d52702a2a39bdfb38db9be0e2c164c199796488fd66428e6cb76d7f9
                                        
                                            GET /wp-content/plugins/js_composer/assets/lib/bower/font-awesome/fonts/fontawesome-webfont.woff?v=4.6.3 HTTP/1.1 
Host: www.trustweb.website
                                        
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://www.trustweb.website/wp-content/plugins/js_composer/assets/lib/bower/font-awesome/css/font-awesome.min.css?ver=5.1.1

                                         
                                         204.93.177.101
HTTP/1.1 200 OK
Content-Type: application/x-font-woff
                                        
Last-Modified: Mon, 01 May 2017 11:41:14 GMT
Content-Length: 90412
Date: Wed, 13 Sep 2017 14:07:35 GMT
Accept-Ranges: bytes
Server: LiteSpeed
Connection: Keep-Alive


--- Additional Info ---
Magic:  data
Size:   90412
Md5:    c8ddf1e5e5bf3682bc7bebf30f394148
Sha1:   6d7e6a5fc802b13694d8820fc0138037c0977d2e
Sha256: adbc4f95eb6d7f2738959cf0ecbc374672fce47e856050a8e9791f457623ac2c
                                        
                                            GET /s/lato/v13/9k-RPmcnxYEPm8CNFsH2gg.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=Open+Sans|Lato
Origin: https://www.trustweb.website

                                         
                                         0.0.0.0
                                        


--- Additional Info ---
                                        
                                            GET /s/lato/v13/9k-RPmcnxYEPm8CNFsH2gg.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=Open+Sans|Lato
Origin: https://www.trustweb.website

                                         
                                         0.0.0.0
                                        


--- Additional Info ---
                                        
                                            GET /s/opensans/v14/cJZKeOuBrn4kERxqtaUH3T8E0i7KZn-EPnyo3HZu7kw.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=Open+Sans|Lato
Origin: https://www.trustweb.website

                                         
                                         0.0.0.0
                                        


--- Additional Info ---
                                        
                                            GET /s/opensans/v14/cJZKeOuBrn4kERxqtaUH3T8E0i7KZn-EPnyo3HZu7kw.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=Open+Sans|Lato
Origin: https://www.trustweb.website

                                         
                                         0.0.0.0
                                        


--- Additional Info ---