Overview

URL smarsh.com
IP35.185.32.196
ASN
Location United States
Report completed2018-05-26 02:27:58 CEST
StatusLoading report..
urlquery Alerts No alerts detected


Settings

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


Intrusion Detection Systems

Suricata /w Emerging Threats Pro  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 4 reports on IP: 35.185.32.196

Date UQ / IDS / BL URL IP
2018-11-28 18:37:56 +0100
0 - 0 - 2 communityprotheme.com/ 35.185.32.196
2018-07-25 22:17:42 +0200
0 - 0 - 2 communityprotheme.com/newappdoc-word-pad/app/ (...) 35.185.32.196
2018-04-01 22:51:29 +0200
0 - 0 - 0 www.smarsh.com/ 35.185.32.196
2018-04-01 22:48:40 +0200
0 - 0 - 0 https://www.smarsh.com/ 35.185.32.196

Last 10 reports on ASN:

Date UQ / IDS / BL URL IP
2018-12-12 20:51:44 +0100
0 - 0 - 1 www.lawfirm-index.com/images/sidebar_right.pn (...) 185.145.130.91
2018-12-12 20:51:24 +0100
0 - 1 - 0 propendrychard.faith/ 198.54.117.200
2018-12-12 20:51:12 +0100
0 - 0 - 0 103.111.219.138 103.111.219.138
2018-12-12 20:50:32 +0100
0 - 2 - 0 download.red-gate.com/checkforupdates/SQLData (...) 143.204.47.123
2018-12-12 20:47:53 +0100
0 - 1 - 0 magariproject.es/ 34.253.142.53
2018-12-12 20:47:29 +0100
0 - 4 - 0 anywhere.webrootcloudav.com/zerol/wsainstall.exe 143.204.47.85
2018-12-12 20:47:23 +0100
0 - 0 - 1 https://server.jsecoin.com/load/141/howdoyoup (...) 35.190.24.124
2018-12-12 20:46:09 +0100
0 - 0 - 0 invoiceviewer.club 198.54.120.132
2018-12-12 20:45:23 +0100
0 - 0 - 1 https://d26tn7krurvwde.cloudfront.net/install (...) 143.204.51.22
2018-12-12 20:45:15 +0100
0 - 0 - 1 xc.05cg.com/xiaz/21.05@1616_128363.exe 114.55.188.114

Last 10 reports on domain: smarsh.com

Date UQ / IDS / BL URL IP
2018-12-10 20:38:33 +0100
0 - 0 - 0 go.smarsh.com/v/V3Bg000Kh20T300GB8z1cs0 199.15.213.48
2018-09-09 17:52:50 +0200
0 - 0 - 0 www2.smarsh.com/r/9442/1/673852917/open/1 35.174.150.168
2018-09-07 11:49:00 +0200
0 - 0 - 0 www2.smarsh.com/r/9442/1/673852917/open/1 52.202.69.186
2018-07-25 17:38:50 +0200
0 - 0 - 0 https://smarshencrypt.smarsh.com/smarshEncrypt 74.85.246.60
2018-07-23 22:11:18 +0200
0 - 0 - 0 smarshencrypt.smarsh.com/prinsite/my/t_secure (...) 74.85.246.60
2018-05-11 03:23:05 +0200
0 - 0 - 0 https://smarshencrypt.smarsh.com/smarshEncrypt 74.85.246.60
2018-04-12 14:07:46 +0200
0 - 0 - 0 https://smarshencrypt.smarsh.com/prinsite/my/ (...) 74.85.246.60
2018-04-04 11:15:13 +0200
0 - 0 - 0 https://identity.smarsh.com/ 199.47.168.113
2018-04-01 22:51:29 +0200
0 - 0 - 0 www.smarsh.com/ 35.185.32.196
2018-04-01 22:48:40 +0200
0 - 0 - 0 https://www.smarsh.com/ 35.185.32.196


JavaScript

Executed Scripts (84)


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: 193350, repeated: 1) - SHA256: 197d48c6c5dd6e43d11ea4e0e7eeea5dc5d61cc19c529bb932704e45f7e7338f

                                        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(e, t, i, s) {
            var a, o, r = "string" == typeof e ? jQuery("#" + e).first() : e;
            switch (t) {
                case "jquery":
                    o = "Multiple jQuery issue", a = '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":
                    o = "Old jQuery issue", a = "It looks like you are using an old version (" + i + ") of the jQuery library. LayerSlider requires at least version " + s + ' 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>' + o + "</strong><span>" + a + "</span></div>").insertBefore(r)
        },
        removeSlider: function(e) {
            this.slidersList[e] = null, delete this.slidersList[e]
        },
        checkVersions: function(e, t) {
            for (var i = e.split("."), s = t.split("."), a = 0; a < i.length; ++a) {
                if (s.length == a) return !1;
                if (parseInt(i[a]) != parseInt(s[a])) return !(parseInt(i[a]) > parseInt(s[a]))
            }
            return i.length, s.length, !0
        }
    }, Number.prototype.indexOf = function(e) {
        return ("" + this).indexOf(e)
    },
    function(e) {
        "use strict";
        window._layerSliders = {}, e.fn.layerSlider = function(i, s, a, o) {
            i = i || {};
            var r, n = e.fn.jquery;
            if (window._layerSlider.checkVersions("1.8.0", n, "1.8.0")) return (typeof i).match("object|undefined") ? this.each(function(s) {
                r = "LS" + Math.random().toString(36).substr(2, 9), e(this).data("lsSliderUID") || (window._layerSliders[r] = new t(this, e(this), i, r))
            }) : "data" === i ? window._layerSliders[this.data("lsSliderUID")] : "eventData" === i ? window._layerSliders[this.data("lsSliderUID")].api.eventData() : "defaultInitOptions" === i ? window._layerSliders[this.data("lsSliderUID")].defaults.init.options || !1 : "userInitOptions" === i ? window._layerSliders[this.data("lsSliderUID")].userInitOptions || !1 : "sliderInitOptions" === i ? window._layerSliders[this.data("lsSliderUID")].o || !1 : "originalMarkup" === i ? window._layerSliders[this.data("lsSliderUID")].originalMarkup || !1 : this.each(function(t) {
                var r = window._layerSliders[e(this).data("lsSliderUID")];
                r && r.api.methods(i, s, a, o), r = null
            });
            window._layerSlider.showNotice(e(this), "oldjquery", n, "1.8.0")
        };
        var t = function(t, i, s, a) {
            i.data("lsSliderUID", a).attr("data-layerslider-uid", a);
            var o = this,
                r = o.gsap = window._layerSlider.GSAP ? window._layerSlider.GSAP : window;
            o.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%",
                        preferBlendMode: !1,
                        autoStart: !0,
                        startInViewport: !0,
                        playByScroll: !1,
                        playByScrollSpeed: 1,
                        playByScrollStart: !1,
                        playByScrollSkipSlideBreaks: !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,
                        scrollModifier: 0,
                        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: " + a + ") 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: {
                        $link: !1,
                        index: -1,
                        data: {
                            duration: -1,
                            timeShift: 0,
                            calculatedTimeShift: 0
                        },
                        parallax: {},
                        kenBurns: {
                            scale: 1.2
                        },
                        filter: {}
                    },
                    registerPluginDefaults: function(e, t, i) {
                        o.defaults.slide.options.plugins || (o.defaults.slide.options.plugins = {}), o.defaults.slide.options.plugins[e] = t
                    }
                },
                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(e, t) {
                        var i = {
                            is: {
                                slideBackground: !!e.is("img.ls-bg"),
                                backgroundVideo: !!e.is(".ls-bg-video"),
                                imageLayer: !!e.is("img.ls-layer"),
                                mediaLayer: !1,
                                textLayer: !1,
                                responsive: !0,
                                onSlide: t
                            },
                            should: {},
                            elements: {},
                            settings: {
                                position: "relative",
                                slideIn: t,
                                slideOut: t
                            },
                            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(e) {
                                    return Math.max(this.transitioninend, this.textinend)
                                },
                                loopstart: 0,
                                loopend: 0,
                                transitioninandloopend: function(e) {
                                    return 0 === this.loopend && e.loop.enabled && ("number" == typeof e.loop.startAt || -1 !== e.loop.startAt.indexOf("textinstart") && -1 !== e.loop.startAt.indexOf("textinend") && -1 !== e.loop.startAt.indexOf("allinend")) ? (this.loopstart = o.transitions.layers.timeline.getTiming(e, e.loop.startAt, "loopstart"), this.loopend = -1 !== e.loop.count && e.timeline.loopstart + (e.loop.repeat + 1) * e.loop.duration + e.loop.repeat * e.loop.repeatDelay) : o.debugMode && o.debug.add("warn", "layerTransition.infinite", e.self[0].tagName + "." + e.self.attr("class") + " [ " + e.self.html().substr(0, 30) + "... ]"), Math.max(this.transitioninend, this.loopend)
                                },
                                textinandloopend: function(e) {
                                    return Math.max(this.textinend, this.loopend)
                                },
                                allinandloopend: function(e) {
                                    return Math.max(this.allinend(), this.loopend)
                                },
                                textoutstart: 0,
                                textoutend: 0,
                                textoutandloopend: function(e) {
                                    return Math.max(this.textoutend, this.loopend)
                                },
                                transitionoutstart: function(e) {
                                    return Math.max(this.allinandloopend(), this.textoutend)
                                },
                                transitionoutend: 0,
                                alloutend: function(e) {
                                    return Math.max(this.transitionoutend, this.textoutend, this.allinend())
                                },
                                alloutandloopend: function(e) {
                                    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() {
                                            o.transitions.layers.in.onStart(e)
                                        },
                                        onComplete: function() {
                                            o.transitions.layers.in.onComplete(e)
                                        },
                                        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() {
                                            o.transitions.layers.out.onStart(e)
                                        },
                                        onComplete: function() {
                                            o.transitions.layers.out.onComplete(e)
                                        },
                                        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: i.is,
                            should: i.should,
                            elements: i.elements,
                            settings: i.settings,
                            styleSettings: i.styleSettings,
                            mediaSettings: i.mediaSettings,
                            mediaProperties: i.mediaProperties,
                            timeline: i.timeline,
                            in : i.transitionProperties.in,
                            inLayerFrom: i.transitionProperties.in.layerFrom,
                            inLayerFromCSS: i.transitionProperties.in.layerFrom.css,
                            inLayerStyleFrom: i.transitionProperties.in.layerStyleFrom,
                            inLayerStyleFromCSS: i.transitionProperties.in.layerStyleFrom.css,
                            inClipFrom: i.transitionProperties.in.clipFrom,
                            inClipFromCSS: i.transitionProperties.in.clipFrom.css,
                            inLayerTo: i.transitionProperties.in.layerTo,
                            inLayerToCSS: i.transitionProperties.in.layerTo.css,
                            inLayerStyleTo: i.transitionProperties.in.layerStyleTo,
                            inLayerStyleToCSS: i.transitionProperties.in.layerStyleTo.css,
                            inClipTo: i.transitionProperties.in.clipTo,
                            inClipToCSS: i.transitionProperties.in.clipTo.css,
                            inClipShouldBeConverted: i.transitionProperties.in.clipShouldBeConverted,
                            inLayerShouldBeConverted: i.transitionProperties.in.layerShouldBeConverted,
                            inLayerStyleShouldBeConvertedFrom: i.transitionProperties.in.layerStyleShouldBeConvertedFrom,
                            inLayerStyleShouldBeConvertedTo: i.transitionProperties.in.layerStyleShouldBeConvertedTo,
                            textIn: i.transitionProperties.textIn,
                            textInNodesFrom: i.transitionProperties.textIn.nodesFrom,
                            textInNodesTo: i.transitionProperties.textIn.nodesTo,
                            textInNodesToCSS: i.transitionProperties.textIn.nodesTo.css,
                            textInShouldBeConverted: i.transitionProperties.textIn.shouldBeConverted,
                            out: i.transitionProperties.out,
                            outLayerFrom: i.transitionProperties.out.layerFrom,
                            outLayerFromCSS: i.transitionProperties.out.layerFrom.css,
                            outLayerStyleFrom: i.transitionProperties.out.layerStyleFrom,
                            outLayerStyleFromCSS: i.transitionProperties.out.layerStyleFrom.css,
                            outLayerTo: i.transitionProperties.out.layerTo,
                            outLayerToCSS: i.transitionProperties.out.layerTo.css,
                            outLayerStyleTo: i.transitionProperties.out.layerStyleTo,
                            outLayerStyleToCSS: i.transitionProperties.out.layerStyleTo.css,
                            outClipTo: i.transitionProperties.out.clipTo,
                            outClipToCSS: i.transitionProperties.out.clipTo.css,
                            outClipShouldBeConverted: i.transitionProperties.out.clipShouldBeConverted,
                            outLayerShouldBeConverted: i.transitionProperties.out.layerShouldBeConverted,
                            outLayerStyleShouldBeConvertedFrom: i.transitionProperties.out.layerStyleShouldBeConvertedFrom,
                            outLayerStyleShouldBeConvertedTo: i.transitionProperties.out.layerStyleShouldBeConvertedTo,
                            textOut: i.transitionProperties.textOut,
                            textOutNodesFrom: i.transitionProperties.textOut.nodesFrom,
                            textOutNodesTo: i.transitionProperties.textOut.nodesTo,
                            textOutShouldBeConverted: i.transitionProperties.textOut.shouldBeConverted,
                            loop: i.transitionProperties.loop,
                            loopFrom: i.transitionProperties.loop.from,
                            loopFromCSS: i.transitionProperties.loop.from.css,
                            loopTo: i.transitionProperties.loop.to,
                            loopToCSS: i.transitionProperties.loop.to.css,
                            loopClipTo: i.transitionProperties.loop.clipTo,
                            loopClipToCSS: i.transitionProperties.loop.clipTo.css,
                            loopClipShouldBeConverted: i.transitionProperties.loop.clipShouldBeConverted,
                            loopLayerShouldBeConverted: i.transitionProperties.loop.layerShouldBeConverted,
                            hover: i.transitionProperties.hover,
                            hoverFrom: i.transitionProperties.hover.from,
                            hoverFromCSS: i.transitionProperties.hover.from.css,
                            hoverTo: i.transitionProperties.hover.to,
                            hoverToCSS: i.transitionProperties.hover.to.css,
                            hoverShouldBeConverted: i.transitionProperties.hover.shouldBeConverted,
                            parallax: i.transitionProperties.parallax,
                            kenBurns: i.transitionProperties.kenBurns,
                            clip: i.transitionProperties.clip,
                            filter: i.transitionProperties.filter,
                            transformPerspective: i.transitionProperties.transformPerspective,
                            init: i.transitionProperties.init,
                            reset: i.transitionProperties.reset
                        }
                    }
                }
            }, o.slides = {
                count: 0,
                first: {},
                prev: {},
                current: {},
                next: {},
                init: function() {
                    if (!document.body.contains(t)) return !1;
                    for (var s = i.find("> .ls-layer, > .ls-slide"), a = 0, r = o.defaults.slide.keys, n = 0, l = s.length; n < l; n++) {
                        var d = e(s[n]),
                            u = d[0].style,
                            p = e.extend(!0, {}, o.defaults.slide.options);
                        if (o.slides.count++, d.removeClass("ls-layer").addClass("ls-slide").css({
                                width: o.slider.initial.originalWidth,
                                height: o.slider.initial.originalHeight
                            }).appendTo(o.slider.$hiddenWrapper), d.data("ls"))
                            for (var c = d.data("ls").toLowerCase().split(";"), h = 0; h < c.length; h++) {
                                var m, f, g = c[h].split(":");
                                g[0] = e.trim(g[0]), g[1] = e.trim(g[1]), "" !== g[0] && void 0 !== r[g[0]] && (m = void 0 === r[g[0]][1] ? g[0] : r[g[0]][1], f = o.functions.convert.properties(g[1]), -1 === m.toLowerCase().indexOf("duration") && -1 === m.toLowerCase().indexOf("delay") && "timeShift" != m || (f /= 1e3), p[r[g[0]][0]] || (p[r[g[0]][0]] = {}), p[r[g[0]][0]][m] = f)
                            }
                        if (p.plugins && !e.isEmptyObject(p.plugins))
                            for (var v in p.plugins)
                                if (d.data("ls-plugin-" + v)) {
                                    var y = d.data("ls-plugin-" + v).toLowerCase().split(";"),
                                        b = {};
                                    for (var S in p.plugins[v]) b[S.toLowerCase()] = S;
                                    for (var w = 0; w < y.length; w++) {
                                        var x, T = y[w].split(":");
                                        T[0] = e.trim(T[0]), "" !== T[0] && (x = o.functions.convert.properties(e.trim(T[1])), -1 === T[0].indexOf("duration") && -1 === T[0].indexOf("delay") || (x /= 1e3), b[T[0]] ? p.plugins[v][b[T[0]]] = x : p.plugins[v][T[0]] = x)
                                    }
                                } else delete p.plugins[v];
                        if (d.children("a.ls-link").length && (p.data.$link = d.children("a.ls-link").first().css({
                                zIndex: 5
                            }).attr("data-ls-slide-link", a + 1).appendTo(o.slider.$layersWrapper), o.layers.set.smartLinks(p.data.$link)), p.data.$backgroundVideo = d.children('[data-ls*="backgroundvideo"]').first(), p.data.$backgroundVideo.length && (null !== p.data.$backgroundVideo.attr("data-ls").split("backgroundvideo")[1].split(";")[0].match(/(true|enabled|on|1)/i) ? (p.data.$backgroundVideo.addClass("ls-bg-video").css({
                                width: "auto",
                                height: "auto"
                            }).children("video, audio, iframe").css({
                                width: "100%",
                                height: "100%"
                            }), p.data.$backgroundVideo.append(e('<div class="ls-bg-video-overlay"></div>'))) : p.data.$backgroundVideo = !1), d.find("> .ls-bg").length && (p.data.$background = d.find("> .ls-bg").first()), !p.data.thumbnail) {
                            var C;
                            d.find("> .ls-tn").length ? C = d.find("> .ls-tn").first() : d.find("> .ls-bg").length && (C = d.find("> .ls-bg").first()), C ? (p.data.thumbnail = o.functions.getURL(C), p.data.tnAlt = o.functions.getALT(C)) : p.data.thumbnail = o.o.skinsPath + o.o.skin + "/nothumb.png"
                        }(p.data.customtransition2d || p.data.customtransition3d) && "undefined" == typeof layerSliderCustomTransitions && (delete p.data.customtransition2d, delete p.data.customtransition3d, o.debugMode && o.debug.add("warn", "sliderInit.customTransitions", a + 1)), "visible" === u.overflow && (p.data.overflow = "visible"), p.data.backgroundColor || (p.data.backgroundColor = "" === d[0].style.backgroundColor ? "transparent" : d[0].style.backgroundColor), o.slides[++a] = {}, o.slides[a].data = e.extend(!0, {}, o.defaults.slide.options.data, p.data), o.slides[a].parallax = p.parallax, o.slides[a].kenBurns = p.kenBurns, o.slides[a].filter = p.filter, o.slides[a].index = a, o.slides[a].$layers = e(), o.slides[a].plugins = p.plugins, o.slider.thumbnails.push(p.data.thumbnail), o.layers.init(d, a)
                    }
                    o.debugMode && o.debug.groupEnd("sliderInit.style")
                },
                set: {
                    slideIndexes: function() {
                        var e = o.slides;
                        e.prev.index = e.current.index, e.current.index = e.next.index, e.next.index = o.slideshow.get.slideInSequence(o.slideshow.direction), e.set.slidesData()
                    },
                    nextSlideIndex: function(e) {
                        var t = o.slides;
                        t.next.index = e, t.set.slidesData()
                    },
                    slidesData: function() {
                        var t = o.slides;
                        t.prev = -1 !== t.prev.index ? e.extend(!0, {}, t[t.prev.index]) : {}, t.current = -1 !== t.current.index ? e.extend(!0, {}, t[t.current.index]) : {}, t.next = -1 !== t.next.index ? e.extend(!0, {}, t[t.next.index]) : {}
                    },
                    firstSlide: function() {
                        var e = o.slides;
                        if (e.first.index = "random" === o.o.firstSlide ? o.o.firstSlide : Math.max(o.functions.convert.properties(o.o.firstSlide, !0), 1), o.o.shuffleSlideshow && o.slides.count > 2 ? o.o.twoWaySlideshow = !1 : o.o.shuffleSlideshow = !1, e.first.index = "random" == e.first.index ? Math.floor(Math.random() * o.slides.count + 1) : e.first.index, document.location.hash)
                            for (var t = 1; t < e.count + 1; t++) e[t].data.deeplink == document.location.hash.split("#")[1] && (e.first.index = t);
                        e.first.index = e.first.index < 1 || e.first.index > o.slides.count ? 1 : e.first.index, o.o.shuffleSlideshow && "random" != o.o.firstSlide && (e.first.index = o.o.firstSlide), o.o.playByScroll && o.slideshow.set.normalizedSequence(), o.debugMode && o.debug.options.firstSlide && (e.first.index = o.debug.options.firstSlide)
                    }
                },
                get: {
                    deeplink: function(e) {
                        return e && o.slides[e] && o.slides[e].data && o.slides[e].data.deeplink ? o.slides[e].data.deeplink : null
                    }
                },
                slide: []
            }, o.layers = {
                $all: e(),
                getStyle: function(e, t) {
                    return -1 != e.indexOf("%") ? parseFloat(e) * t : parseFloat(e)
                },
                init: function(i, s) {
                    if (!document.body.contains(t)) return !1;
                    for (var a, r = i.find('.ls-bg, .ls-l, .ls-layer, *[class^="ls-s"]'), n = 0, l = r.length; n < l; n++) {
                        var d = e(r[n]),
                            u = d[0],
                            p = d.children();
                        if (-1 != d.attr("class").indexOf("ls-s")) {
                            var c = d.attr("class").split("ls-s")[1].split(" ")[0];
                            d.removeClass("ls-s" + c).addClass("ls-layer")
                        } else if (d.hasClass("ls-l")) d.removeClass("ls-l").addClass("ls-layer");
                        else if (!d.is(".ls-bg, .ls-layer")) {
                            d.remove();
                            continue
                        }
                        d.is("a") && 1 === p.length && ((u = (d = d.children().first())[0]).setAttribute("data-ls", u.parentNode.getAttribute("data-ls")), u.parentNode.removeAttribute("data-ls"), d.parent().removeClass("ls-layer"), d.addClass("ls-layer")), d.data(o.defaults.init.dataKey, new o.defaults.layer.options(d, s)), -1 !== d.attr("class").indexOf("ls-linkto-") && this.set.linkTo(d), d.parent().is("a") ? (a = d.parent(), this.set.smartLinks(a)) : a = d, o.slides[s].$layers = o.slides[s].$layers.add(a)
                    }
                },
                set: {
                    smartLinks: function(t) {
                        var i = t.attr("href"),
                            s = t.attr("target"),
                            n = "";
                        if (s && -1 !== s.indexOf("ls-scroll")) {
                            switch (i) {
                                case "pagetop":
                                    n = "Scroll to page top";
                                    break;
                                case "pagebottom":
                                    n = "Scroll to page bottom";
                                    break;
                                case "slidertop":
                                    n = "Scroll to the top of the slider";
                                    break;
                                case "":
                                case "sliderbottom":
                                    n = "Scroll to the bottom of the slider";
                                    break;
                                default:
                                    n = "Scroll to a specified location on the page"
                            }
                            o.layers.set.ariaLabel(t, n), t.on("click." + a, function(t) {
                                t.preventDefault();
                                var s, a = document.body.scrollHeight - o.device.viewportHeight;
                                if (i) switch (i) {
                                    case "pagetop":
                                        s = 0;
                                        break;
                                    case "pagebottom":
                                        s = o.device.docHeight - o.device.viewportHeight;
                                        break;
                                    case "slidertop":
                                        s = o.slider.offsetTop;
                                        break;
                                    case "":
                                    case "sliderbottom":
                                        s = o.slider.offsetTop + o.slider.height;
                                        break;
                                    default:
                                        s = e(i).first().length ? e(i).last().offset().top : o.slider.offsetTop + o.slider.height
                                }
                                s += o.o.scrollModifier, s = Math.min(s, a), s = Math.max(0, s), r.TweenMax.to("html, body", 1, {
                                    scrollTop: s,
                                    ease: r.Quint.easeInOut
                                })
                            })
                        }
                        if (-1 !== o.defaults.init.controls.indexOf(i) || i.match(/^\#[0-9]/)) {
                            var l = e.trim(i.toLowerCase().split("#")[1]),
                                d = parseInt(l);
                            switch (l) {
                                case "prev":
                                    n = "jump to the previous slide";
                                    break;
                                case "next":
                                    n = "jump to the next slide";
                                    break;
                                case "start":
                                    n = "start slideshow";
                                    break;
                                case "stop":
                                    n = "stop slideshow";
                                    break;
                                case "replay":
                                    n = "replay slide";
                                    break;
                                case "reverse":
                                    n = "reverse slide";
                                    break;
                                case "reverse-replay":
                                    n = "reverse, than replay slide";
                                    break;
                                default:
                                    "number" == typeof d && d === d && (n = "jump to slide " + d)
                            }
                            o.layers.set.ariaLabel(t, n), t.on("click." + a, function(e) {
                                if (e.preventDefault(), -1 !== ["prev", "next", "start", "stop"].indexOf(l)) o.navigation[l]("clicked");
                                else if ("number" == typeof d && d === d) o.slideshow.changeTo(d, !0, !0);
                                else if (!o.slider.state.changingSlides) switch (l) {
                                    case "replay":
                                        o.api.methods("replay");
                                        break;
                                    case "reverse":
                                        o.api.methods("reverse");
                                        break;
                                    case "reverse-replay":
                                        o.api.methods("reverse", !0)
                                }
                            })
                        }
                    },
                    ariaLabel: function(e, t) {
                        e.attr("aria-label") || e.attr("aria-label", t)
                    },
                    linkTo: function(t) {
                        for (var s = t.attr("class").split(" "), r = 1, n = 0; n < s.length; n++) - 1 != s[n].indexOf("ls-linkto-") && (r = parseInt(s[n].split("ls-linkto-")[1]));
                        t.data(o.defaults.init.dataKey).settings.linkedToSlide = r, t.css({
                            cursor: "pointer"
                        }).on("click." + a, function(t) {
                            t.preventDefault(), i.layerSlider(e(this).data(o.defaults.init.dataKey).settings.linkedToSlide)
                        })
                    },
                    wrappers: function(e, t, i) {
                        t.is.slideBackground || t.is.backgroundVideo ? (t.elements.$bgWrapper = e.closest(".ls-bg-wrap"), t.elements.$bgOuterWrapper = e.closest(".ls-bg-outer")) : (t.elements.$wrapper = e.closest(".ls-in-out"), t.elements.$wrapper.data(o.defaults.init.dataKey, {}), t.settings.wrapperData = t.elements.$wrapper.data(o.defaults.init.dataKey), t.elements.$clipWrapper = e.closest(".ls-clip"), t.elements.$clipWrapper.data(o.defaults.init.dataKey, {}), t.settings.clipWrapperData = t.elements.$clipWrapper.data(o.defaults.init.dataKey), t.elements.$loopWrapper = e.closest(".ls-loop"), t.elements.$loopWrapper.data(o.defaults.init.dataKey, {}), t.settings.loopWrapperData = t.elements.$loopWrapper.data(o.defaults.init.dataKey)), t.parallax.enabled && (t.elements.$parallaxWrapper = e.closest(".ls-parallax"), t.elements.$parallaxWrapper.data(o.defaults.init.dataKey, {
                            parallax: {}
                        }), t.settings.parallaxWrapperData = t.elements.$parallaxWrapper.data(o.defaults.init.dataKey), o.transitions.layers.parallax.addLayer(t.elements.$parallaxWrapper, t.settings.parallaxWrapperData.parallax, t, i)), t.hover.enabled && !o.slides[i].data.globalhover && o.transitions.layers.hover.set(e, t), o.browser.isSafari ? t.elements.$outerWrapper = e.closest(".ls-z") : t.elements.$outerWrapper = t.parallax.enabled ? t.elements.$parallaxWrapper : t.elements.$bgWrapper ? t.elements.$bgOuterWrapper : t.elements.$wrapper
                    },
                    style: function(e) {
                        var t, i, s, a, r, n, l, d, u, p, c, h, m, f, g, v, y, b, S, w, x, T, C = e[0],
                            k = e.data(o.defaults.init.dataKey),
                            I = C.style,
                            O = o.layers,
                            L = 0,
                            $ = 0,
                            B = !1,
                            P = C.getBoundingClientRect();
                        if (d = "" !== I.paddingLeft ? O.getStyle(I.paddingLeft, o.slider.initial.percW) : parseFloat(e.css("padding-left")), p = "" !== I.paddingRight ? O.getStyle(I.paddingRight, o.slider.initial.percW) : parseFloat(e.css("padding-right")), u = "" !== I.paddingTop ? O.getStyle(I.paddingTop, o.slider.initial.percH) : parseFloat(e.css("padding-top")), c = "" !== I.paddingBottom ? O.getStyle(I.paddingBottom, o.slider.initial.percH) : parseFloat(e.css("padding-bottom")), h = "" !== I.marginLeft ? O.getStyle(I.marginLeft, o.slider.initial.percW) : parseFloat(e.css("margin-left")), m = "" !== I.marginTop ? O.getStyle(I.marginTop, o.slider.initial.percH) : parseFloat(e.css("margin-top")), C.style.margin = "0", g = "" !== I.borderLeftWidth ? parseFloat(I.borderLeftWidth) : parseFloat(e.css("border-left-width")), y = "" !== I.borderRightWidth ? parseFloat(I.borderRightWidth) : parseFloat(e.css("border-right-width")), v = "" !== I.borderTopWidth ? parseFloat(I.borderTopWidth) : parseFloat(e.css("border-top-width")), b = "" !== I.borderBottomWidth ? parseFloat(I.borderBottomWidth) : parseFloat(e.css("border-bottom-width")), 1 === o.media.$allMediaLayers.filter(e).length || e.children("iframe").length) {
                            var W = e.children(),
                                M = W.attr("width") ? W.attr("width") : W.width(),
                                _ = W.attr("height") ? W.attr("height") : W.height();
                            300 === parseInt(M) && 150 === parseInt(_) && (M = 640, _ = 360), "" !== C.style.width && "auto" !== C.style.width || e.css("width", M), "" !== C.style.height && "auto" !== C.style.height || e.css("height", _), "100%" === I.width && "100%" === I.height && (I.left = "50%", I.top = "50%", k.mediaSettings.fullsize = !0), B = M / _, W.css({
                                width: "100%",
                                height: "100%"
                            })
                        }
                        var z = k.attributes;
                        e.is("img") && (S = (a = e.data("preloadedWidth")) / (r = e.data("preloadedHeight")), (!I.width && !I.height || "auto" === I.width && "auto" === I.height) && z && (z.width && z.height ? (-1 === z.width.indexOf("%") ? i = parseInt(z.width) : (L = parseInt(z.width), i = O.getStyle(z.width, o.slider.initial.percW)), -1 === z.height.indexOf("%") ? s = parseInt(z.height) : ($ = parseInt(z.height), s = O.getStyle(z.height, o.slider.initial.percH))) : z.maxWidth && (e[0].style.width = z.maxWidth + "px", i = z.maxWidth, s = e.height()))), x = P.width ? P.width : P.right - P.left, T = P.height ? P.height : P.bottom - P.top, i || (i = I.width, -1 !== I.width.indexOf("%") && (L = parseInt(I.width)), i = "" !== i && "auto" !== i ? O.getStyle(i, o.slider.initial.percW) : x - d - p - g - y, i = i || "auto"), s || (s = I.height, -1 !== I.height.indexOf("%") && ($ = parseInt(I.height)), s = (s = "" !== s && "auto" !== s ? O.getStyle(s, o.slider.initial.percH) : T - u - c - v - b) || "auto"), w = B || i / s, !e.is("img") || I.width || I.height || z && (!z || z.width || z.height) || a === i && r === s || (a !== i ? s = (i = a > 5 ? a : i) / (w = a > 5 ? S : w) : r !== s && (i = (s = r > 5 ? r : s) * (w = r > 5 ? r : w))), parseFloat(e.css("opacity")), n = g + d + i + p + y, l = v + u + s + c + b, t = "" !== I.clip && I.clip, I.clip = "", f = I.webkitFilter || I.filter;
                        var F = function(e) {
                            var t = e;
                            return e && -1 !== e.indexOf("px ") && (e = e.replace("px", "").split(" "), t = Math.round(parseInt(e[0]) / i * 100) + "%"), t
                        };
                        k.original = {
                            clip: t,
                            clipShouldBeConverted: !1,
                            left: I.left ? I.left : "0",
                            top: I.top ? I.top : "0",
                            width: Math.ceil(i),
                            height: Math.ceil(s),
                            percentWidth: L,
                            percentHeight: $,
                            outerWidth: n,
                            outerHeight: l,
                            styleWidth: I.width,
                            styleHeight: I.height,
                            ratio: w,
                            paddingLeft: d,
                            paddingTop: u,
                            paddingRight: p,
                            paddingBottom: c,
                            marginLeft: h,
                            marginTop: m,
                            borderLeftWidth: g,
                            borderTopWidth: v,
                            borderRightWidth: y,
                            borderBottomWidth: b,
                            borderRadius: F(e.css("borderTopLeftRadius")) + " " + F(e.css("borderTopRightRadius")) + " " + F(e.css("borderBottomRightRadius")) + " " + F(e.css("borderBottomLeftRadius")),
                            fontSize: parseFloat(e.css("font-size")),
                            lineHeight: e.css("line-height"),
                            letterSpacing: e.css("letter-spacing"),
                            color: e.css("color"),
                            zIndex: parseInt(e.css("z-index")) || "auto",
                            filter: f,
                            backgroundColor: e.css("background-color"),
                            dataLS: e.attr("data-ls") || "",
                            styles: e.attr("style") || ""
                        }, I.zIndex = "auto", k.responsive = {
                            left: I.left ? I.left : "0",
                            top: I.top ? I.top : "0",
                            width: i,
                            height: s
                        }
                    },
                    properties: function(t, i, s) {
                        var a = t.data(o.defaults.init.dataKey);
                        t.data("ls");
                        if (a.is.textLayer = !t.is("img") && !a.is.mediaLayer, a.self = t, t.data("ls"))
                            for (var n = o.defaults.layer.keys, l = t.data("ls").split(";"), d = t.data("ls").toLowerCase().split(";"), u = 0; u < d.length; u++)
                                if (e.trim(d[u])) {
                                    var p = d[u].indexOf(":"),
                                        c = [d[u].substring(0, p), d[u].substring(p + 1)],
                                        h = null,
                                        m = null,
                                        f = null,
                                        g = null,
                                        v = null;
                                    if ("" !== (h = e.trim(c[0])))
                                        if (h = h.replace("split", "text"), void 0 !== n[h]) {
                                            if (m = n[h][0], v = "overlay" === h ? e.trim(l[u].substring(p + 1)) : o.functions.convert.properties(e.trim(c[1])), c[1] && -1 !== c[1].indexOf("random") && (h.match(/(text)/) || (v = o.functions.convert.randomProperties(v, m)), a.should.update || (a.should.update = !0)), "number" == typeof v && m.match(/(duration|startat|shift|delay)/i) && (v /= 1e3), h.match(/(fade)(.+)/)) switch (v) {
                                                case !0:
                                                    v = 0;
                                                    break;
                                                case !1:
                                                    v = 1
                                            }
                                            void 0 !== (g = n[h][1]) ? "" !== v ? "object" == typeof v ? h.match(/(text)/) ? g.match(/(converted)/i) ? a[g][m] = v : a[g].cycle[m] = v : (f = o.functions.convert.properties(e.trim(v[0])), o.debugMode && o.debug.add("warn", "layerInit.prop1", [h, v, f]), "number" == typeof f && m.match(/(duration|startat|shift|delay)/i) && (f /= 1e3), a[g][m] = f) : h.match(/(text)/) && -1 !== v.toString().indexOf("random") ? a[g].random[m] = v : a[g][m] = v : o.debugMode && o.debug.add("warn", "layerInit.prop2", h) : a[m][h] = v
                                        } else "clip" === h ? (a.original.clip = c[1], a.original.clipShouldBeConverted = !0) : o.debugMode && o.debug.add("warn", "layerInit.prop4", h)
                                }
                        if (o.browser.isOld && (a.in.enabled = !0, a.textIn.enabled = !1, a.textOut.enabled = !1, a.textIn.type = null, a.textOut.type = null), a.in.enabled && (a.inLayerTo.ease = a.inLayerStyleTo.ease = a.inClipTo.ease = o.functions.convert.easing(a.in.ease)), void 0 !== a.inLayerStyleShouldBeConvertedFrom.borderRadius && (a.inLayerStyleShouldBeConvertedTo.borderRadius = a.original.borderRadius), void 0 !== a.outLayerStyleShouldBeConvertedTo.borderRadius && (a.outLayerStyleShouldBeConvertedFrom.borderRadius = a.original.borderRadius), a.inLayerStyleFromCSS.backgroundColor && (a.inLayerStyleToCSS.backgroundColor = a.original.backgroundColor), a.outLayerStyleToCSS.backgroundColor && (a.outLayerStyleFromCSS.backgroundColor = a.original.backgroundColor), a.inLayerStyleFromCSS.color && (a.inLayerStyleToCSS.color = a.original.color), a.outLayerStyleToCSS.color && (a.outLayerStyleFromCSS.color = a.original.color), void 0 !== a.inLayerStyleShouldBeConvertedFrom.width && (a.inLayerStyleShouldBeConvertedTo.width = a.original.width), void 0 !== a.outLayerStyleShouldBeConvertedTo.width && (a.outLayerStyleShouldBeConvertedFrom.width = a.original.width), void 0 !== a.inLayerStyleShouldBeConvertedFrom.height && (a.inLayerStyleShouldBeConvertedTo.height = a.original.height), void 0 !== a.outLayerStyleShouldBeConvertedTo.height && (a.outLayerStyleShouldBeConvertedFrom.height = a.original.height), void 0 !== a.out.showUntil && 0 !== a.out.showUntil && (a.out.startAt = "transitioninend + " + a.out.showUntil), -1 !== a.out.startAt.indexOf("slidechangeonly") && "slidechangeonly" !== a.out.startAt && (a.out.startAt = "slidechangeonly"), a.out.enabled && (a.outLayerTo.ease = a.outLayerStyleTo.ease = a.outClipTo.ease = o.functions.convert.easing(a.out.ease)), e.isNumeric(a.loop.count) && (a.loop.count > 0 || -1 === a.loop.count) && !1 !== a.loop.enabled ? (a.loop.enabled = !0, a.loopTo.ease = a.loopClipTo.ease = o.functions.convert.easing(a.loop.ease), -1 !== a.loop.count ? a.loop.yoyo ? a.loop.repeat = 2 * a.loop.count - 1 : a.loop.repeat = a.loop.count - 1 : a.loop.repeat = -1) : a.loop.enabled = !1, (!e.isEmptyObject(a.hoverToCSS) || a.hoverShouldBeConverted.x || a.hoverShouldBeConverted.y || a.hoverShouldBeConverted.borderRadius || a.hoverShouldBeConverted.filter) && !1 !== a.hover.enabled ? (a.hover.enabled = !0, a.hover.easeOut || (a.hover.easeOut = a.hover.easeIn), a.hover.easeIn = o.functions.convert.easing(a.hover.easeIn), a.hover.easeOut = o.functions.convert.easing(a.hover.easeOut, !0), a.hover.durationOut || (a.hover.durationOut = a.hover.durationIn), r.TweenMax.set(t[0], {
                                autoCSS: !1,
                                css: {
                                    transformPerspective: a.hoverShouldBeConverted.transformPerspective
                                }
                            })) : a.hover.enabled = !1, a.parallax.level && e.isNumeric(a.parallax.level) && 0 !== a.parallax.level && !1 !== a.parallax.enabled ? a.parallax.enabled = !0 : a.parallax.enabled = !1, a.is.slideBackground) {
                            var y = {
                                scale: 1,
                                rotation: 0
                            };
                            if (o.slides[i].kenBurns.zoom && (a.kenBurns = o.slides[i].kenBurns), a.kenBurns.zoom) {
                                switch (a.kenBurns.from = {}, a.kenBurns.to = {}, a.kenBurns.zoom) {
                                    case "out":
                                        a.kenBurns.from.scale = a.kenBurns.scale || 1, a.kenBurns.from.rotation = a.kenBurns.rotation || 0, a.kenBurns.to = y;
                                        break;
                                    case "in":
                                        a.kenBurns.from = y, a.kenBurns.to.scale = a.kenBurns.scale || 1, a.kenBurns.to.rotation = a.kenBurns.rotation || 0
                                }
                                delete a.kenBurns.scale, delete a.kenBurns.rotation
                            } else a.kenBurns.from = y, a.kenBurns.to = y;
                            e.isEmptyObject(o.slides[i].filter) || (o.slides[i].filter.from && (a.filter.values.bgFrom = o.transitions.layers.filters.convert(o.slides[i].filter.from)), o.slides[i].filter.to && (a.filter.values.bgTo = o.transitions.layers.filters.convert(o.slides[i].filter.to)))
                        }
                        if (a.textIn.type && -1 === o.defaults.layer.splitTypeKeys.indexOf(a.textIn.type) && (o.debugMode && o.debug.add("warn", "layerInit.splitType3a", [t[0].tagName, a.textIn.type]), delete a.textIn.type, delete a.textIn.ns, a.textIn.enabled = !1), a.textOut.type && -1 === o.defaults.layer.splitTypeKeys.indexOf(a.textOut.type) && (o.debugMode && o.debug.add("warn", "layerInit.splitType3b", [t[0].tagName, a.textOut.type]), delete a.textOut.type, delete a.textOut.ns, a.textOut.enabled = !1), a.textIn.type || a.textOut.type) {
                            var b = 0;
                            if (a.is.textLayer ? (a.textIn.type && (a.textIn.enabled = !0, a.textInNodesTo.ease = o.functions.convert.easing(a.textInNodesTo.ease), a.textIn.split = a.textIn.type.split("_")[0], t.children().length && o.debugMode && (b = 1)), a.textOut.type && (a.textOut.enabled = !0, a.textOutNodesTo.ease = o.functions.convert.easing(a.textOutNodesTo.ease)), a.textOut.enabled && a.textOut.type.split("_")[0] !== a.textIn.split && (a.textIn.split += ", " + a.textOut.type.split("_")[0], t.children().length && o.debugMode && (b = 1)), -1 !== a.textIn.split.indexOf("chars") && -1 === a.textIn.split.indexOf("words") && (a.textIn.split += ", words"), -1 !== a.textIn.split.indexOf("words") && -1 === a.textIn.split.indexOf("lines") && (a.textIn.split += ", lines")) : (delete a.textIn.type, delete a.textOut.type, delete a.textIn.ns, delete a.textOut.ns, o.debugMode && (b = 2)), o.debugMode && 0 !== b && i && !s) switch (b) {
                                case 1:
                                    o.debug.add("warn", "layerInit.splitType1", [t.prop("nodeName"), i]);
                                    break;
                                case 2:
                                    o.debug.add("warn", "layerInit.splitType2", [i, t.prop("nodeName")])
                            }
                        }
                        if ((a.original.clip || a.inClipShouldBeConverted.clip || a.outClipShouldBeConverted.clip || a.loopClipShouldBeConverted.clip) && (a.clip.enabled = !0), a.in.enabled && a.inLayerToCSS.scale && (delete a.inLayerToCSS.scaleX, delete a.inLayerToCSS.scaleY), a.out.enabled && a.outLayerToCSS.scale && (delete a.outLayerToCSS.scaleX, delete a.outLayerToCSS.scaleY), a.inLayerStyleShouldBeConvertedFrom.filter && (a.filter.values.in = o.transitions.layers.filters.convert(a.inLayerStyleShouldBeConvertedFrom.filter)), a.filter.values.style = o.transitions.layers.filters.convert(a.original.filter), a.outLayerStyleShouldBeConvertedTo.filter && (a.filter.values.out = o.transitions.layers.filters.convert(a.outLayerStyleShouldBeConvertedTo.filter)), a.loopLayerShouldBeConverted.filter && (a.filter.values.loop = o.transitions.layers.filters.convert(a.loopLayerShouldBeConverted.filter)), a.hoverShouldBeConverted.filter && (a.filter.values.hover = o.transitions.layers.filters.convert(a.hoverShouldBeConverted.filter)), a.in.enabled || (a.in.duration = 0), a.textIn.enabled || (a.textIn.duration = 0), a.loop.enabled || (a.loop.duration = 0), a.textOut.enabled || (a.textOut.duration = 0), a.out.enabled || (a.out.duration = 0), t.attr("data-ls-slidein", i), void 0 !== a.settings.static && "none" !== a.settings.static) {
                            var S = parseInt(a.settings.static);
                            0 !== S && "forever" !== a.settings.static ? (t.attr("data-ls-slideout", S), a.settings.slideOut = S) : a.settings.slideOut = 0, a.is.static = !0, t.attr("data-ls-static", "1")
                        } else t.attr("data-ls-slideout", i);
                        if (a.is.mediaLayer) {
                            var w = t.children("video, audio").eq(0);
                            if (null !== a.mediaSettings.controls) switch (a.mediaSettings.controls) {
                                case !0:
                                    w.prop("controls", !0), w.removeProp("nocontrols").removeAttr("nocontrols");
                                    break;
                                case !1:
                                    w.prop("controls", !1)
                            }
                            a.mediaSettings.volume && (a.mediaSettings.volume < 0 ? a.mediaSettings.volume = 0 : a.mediaSettings.volume > 100 && (a.mediaSettings.volume = 100)), a.is.backgroundVideo && (o.media.setBackgroundVideo(a, t), a.styleSettings.overlay && t.find(".ls-bg-video-overlay").css({
                                backgroundImage: "url(" + a.styleSettings.overlay + ")"
                            }))
                        }
                        a.styleSettings.minfontsize && (a.styleSettings.minfontsize = parseFloat(a.styleSettings.minfontsize)), a.styleSettings.minmobilefontsize && (a.styleSettings.minmobilefontsize = parseFloat(a.styleSettings.minmobilefontsize))
                    }
                },
                get: function(e) {
                    var t = this.$all;
                    if (e) {
                        var i = "in",
                            s = "",
                            a = "",
                            r = ':not(".ls-bg")',
                            n = ':not(".ls-bg-video")'; - 1 == (e = e.toLowerCase()).indexOf("bgvideo") && -1 == e.indexOf("backgroundvideo") || (n = "", e = e.replace("bgvideo", "").replace("backgroundvideo", "")), -1 != e.indexOf("video") && (a += ", > video", e = e.replace("video", "")), -1 != e.indexOf("audio") && (a += ", > audio", e = e.replace("audio", "")), -1 != e.indexOf("html5") && (a += ", > video, > audio", e = e.replace("html5", "")), -1 != e.indexOf("youtube") && (a += ', > 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"]', e = e.replace("youtube", "")), -1 != e.indexOf("vimeo") && (a += ', > iframe[src*="player.vimeo"], > iframe[data-src*="player.vimeo"]', e = e.replace("vimeo", "")), "," == a.charAt(0) && (a = a.substring(2, a.length)), -1 != e.indexOf("out") && (i = "out"), -1 == e.indexOf("img") && -1 == e.indexOf("image") || (s = "img"), -1 == e.indexOf("bg") && -1 == e.indexOf("background") && -1 == e.indexOf("bgonly") || (r = ""), t = -1 != e.indexOf("current") ? t.filter(s + "[data-ls-slide" + i + '="' + o.slides.current.index + '"]' + r + n) : -1 != e.indexOf("next") ? t.filter(s + "[data-ls-slide" + i + '="' + o.slides.next.index + '"]' + r + n) : t.filter(s + r + n), -1 != e.indexOf("notactive") && (t = t.filter(".ls-bg, .ls-bg-video, :hidden"), e = e.replace("notactive", "")), -1 != e.indexOf("active") && (t = t.filter(":visible:not(.ls-bg, .ls-bg-video)"), e = e.replace("active", "")), -1 != e.indexOf("notstatic") && (t = t.filter(':not([data-ls-static="1"])'), e = e.replace("notstatic", "")), -1 != e.indexOf("static") && (t = t.filter('[data-ls-static="1"]'), e = e.replace("static", "")), -1 != e.indexOf("bgonly") && (t = t.filter(".ls-bg"), e = e.replace("bgonly", "")), "" !== a && (t = t.find(a))
                    }
                    return t
                },
                update: {
                    data: function(t, i, s) {
                        var a, r, n;
                        switch (t instanceof jQuery || (t = e(t)), s && t.attr("data-ls", s).data("ls", s), r = t.data(o.defaults.init.dataKey), a = r.is.onSlide, n = r.original, i) {
                            default:
                                case "transitions":
                                r.settings.timelineIsCalculated = !1,
                            o.layers.set.properties(t, a, !0);
                            break;
                            case "all":
                                    t.data(o.defaults.init.dataKey, new o.defaults.layer.options(t, a)),
                                (r = t.data(o.defaults.init.dataKey)).original = n,
                                o.layers.set.properties(t, a, !0),
                                o.layers.set.wrappers(t, r, a)
                        }
                    }
                },
                wrap: function(t, s) {
                    if (!o.slides[t].wrapped && "wrapping" !== o.slides[t].wrapped) {
                        o.slides[t].wrapped = "wrapping";
                        var a = s ? 25 : 0,
                            r = o.slides[t].$layers,
                            n = r.length;
                        r.each(function(s, r) {
                            o.timeouts["slide-" + t + "-layer-" + s] = setTimeout(function() {
                                delete o.timeouts["slide-" + t + "-layer-" + s];
                                var a, l = e(r),
                                    d = l,
                                    u = "",
                                    p = !1,
                                    c = "";
                                l.hasClass("ls-hide-phone") && (c += " ls-hide-on-phone"), l.hasClass("ls-hide-tablet") && (c += " ls-hide-on-tablet"), l.hasClass("ls-hide-desktop") && (c += " ls-hide-on-desktop"), l.removeClass("ls-hide-phone ls-hide-tablet ls-hide-desktop"), d.is("a") && 1 === d.children().length && (p = !0, l = d.find(".ls-layer"));
                                var h = l.data(o.defaults.init.dataKey);
                                if (!h) return !0;
                                if (a = o.slider.$layersWrapper, h.is.backgroundVideo ? a = o.slider.$bgVideosWrapper : h.is.slideBackground && (a = o.slider.$slideBGWrapper), o.layers.set.style(l), o.layers.set.properties(l, t), h.textIn.split) {
                                    var m = new SplitType(l[0], {
                                        split: h.textIn.split
                                    });
                                    h.textIn.type && (h.textIn.ns = m[h.textIn.type.split("_")[0]]), h.textOut.type && (h.textOut.ns = m[h.textOut.type.split("_")[0]])
                                }
                                h.is.slideBackground || h.is.backgroundVideo ? u = '<div class="ls-wrapper ls-bg-outer"><div class="ls-wrapper ls-bg-wrap"></div></div>' : (h.clip.enabled && (u = '<div class="ls-wrapper ls-clip"></div>'), h.loop.enabled && (u = '<div class="ls-wrapper ls-loop">' + u + "</div>"), u = '<div class="ls-wrapper ls-in-out">' + u + "</div>"), h.parallax.enabled && (u = '<div class="ls-wrapper ls-parallax">' + u + "</div>"), o.browser.isSafari && (u = '<div class="ls-wrapper ls-z">' + u + "</div>"), "" !== u ? l.appendTo(a).wrap(u) : l.appendTo(a), !0 === p && d.addClass("ls-layer-link").appendTo(l.parent());
                                var f = {},
                                    g = l.css("mix-blend-mode");
                                g && "normal" !== g && (f["mix-blend-mode"] = g, l.css("mix-blend-mode", "normal")), h.original.customZIndex = 1;
                                var v = parseInt(h.original.zIndex);
                                h.is.backgroundVideo ? f = {
                                    zIndex: h.original.customZIndex
                                } : h.is.slideBackground ? f = {
                                    zIndex: h.original.customZIndex
                                } : (v || (v = s + 101), f.zIndex = v, h.original.customZIndex = v), o.browser.isSafari && (f.transform = "translateZ(" + 3e3 * v + "px )"), o.layers.set.wrappers(l, h, t), h.elements.$outerWrapper.css(f).addClass(c), h.is.slideBackground && h.elements.$bgWrapper.css({
                                    backgroundColor: o.slides[t].data.backgroundColor
                                }), o.layers.$all = o.layers.$all.add(l), o.slides[t].$layers = o.slides[t].$layers.not(d), s === n - 1 && (i.children(".ls-slide").eq(t - 1).empty(), o.slides[t].wrapped = !0)
                            }, a * (s + 1))
                        })
                    }
                }
            }, o.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 == o.slides.count && (o.o.autoStart = !1, o.o.navPrevNext = !1, o.o.navStartStop = !1, o.o.navButtons = !1, o.o.cycles = -1, o.o.forceLoopNum = !1, o.o.autoPauseSlideshow = !0, o.o.firstSlide = 1, o.o.thumbnailNavigation = "disabled"), o.o.autoStart && 1 != o.slides.count || o.functions.setStates(this, {
                        running: !1,
                        paused: !0
                    }), this.set.pauseOnHover(), this.set.sequences()
                },
                set: {
                    pauseOnHover: function() {
                        o.o.pauseOnHover = !0 === o.o.pauseOnHover ? o.defaults.init.options.pauseOnHover : o.o.pauseOnHover, !1 !== o.o.pauseOnHover && i.on("mouseenter." + a, function() {
                            o.slider.state.inFullscreen || (o.functions.setStates(o.slideshow, {
                                pausedByHover: !0
                            }), "slideshowOnly" !== o.o.pauseOnHover && o.transitions.layers.timeline.pause())
                        }).on("mouseleave." + a, function() {
                            var t = 1;
                            o.transitions._slideTimeline && o.transitions._slideTimeline.duration() > o.transitions.layers.timeline.totalDuration && (t = o.transitions.layers.timeline.totalDuration / o.transitions._slideTimeline.duration()), o.functions.setStates(o.slideshow, {
                                pausedByHover: !1
                            }), e("body").hasClass("ls-unselectable") || "slideshowOnly" === o.o.pauseOnHover || o.o.pauseLayers && o.slideshow.isPaused() || o.transitions.layers.timeline.resume(), o.transitions._slideTimeline && o.transitions.layers.timeline.state.finished && o.transitions._slideTimeline.progress() < t && o.functions.setStates(o.transitions.layers.timeline, {
                                finished: !1
                            }), o.slideshow.start()
                        })
                    },
                    sequences: function() {
                        for (var t = 0; t < o.slides.count; t++) o.slideshow.sequence.normal[t] = t + 1;
                        o.slideshow.sequence.randomized = o.functions.shuffleArray(e.merge([], o.slideshow.sequence.normal))
                    },
                    normalizedSequence: function() {
                        var e = o.o.shuffleSlideshow ? "randomized" : "normal",
                            t = o.slideshow.sequence[e],
                            i = o.slideshow.sequence[e].length,
                            s = t.indexOf(o.slides.first.index);
                        o.slideshow.sequence.normalized = [];
                        for (var a = s; a < i; a++) o.slideshow.sequence.normalized.push(t[a]);
                        for (var r = 0; r < s; r++) o.slideshow.sequence.normalized.push(t[r])
                    },
                    prevNext: function(e) {
                        switch (e) {
                            case "prev":
                                o.o.twoWaySlideshow && (o.slideshow.direction = "prev"), o.slideshow.changeTo(o.slideshow.get.slideInSequence("prev"), !0);
                                break;
                            case "next":
                                o.slideshow.direction = "next", o.slideshow.changeTo(o.slideshow.get.slideInSequence("next"), !0)
                        }
                    }
                },
                get: {
                    sequence: function() {
                        var e = "normal";
                        return o.o.playByScroll ? e = "normalized" : o.o.shuffleSlideshow && (e = "randomized"), e
                    },
                    slideInSequence: function(e) {
                        var t = o.slideshow.sequence[this.sequence()],
                            i = t.indexOf(o.slides.current.index);
                        switch (e) {
                            case "prev":
                                return 0 === i ? t[t.length - 1] : t[i - 1];
                            case "next":
                                return i === t.length - 1 ? t[0] : t[i + 1];
                            default:
                                return t[e]
                        }
                    },
                    indexOfSlideInSequence: function(e) {
                        return o.slideshow.sequence[this.sequence()].indexOf(e)
                    }
                },
                cycles: {set: function() {
                        o.o.cycles > 0 && (o.slideshow.curCycle = 1, o.slideshow.cycleSlideIndex = o.slideshow.get.indexOfSlideInSequence(o.slides.first.index))
                    },
                    check: function(e) {
                        if (o.slideshow.get.indexOfSlideInSequence(e) === o.slideshow.cycleSlideIndex) return ++o.slideshow.curCycle === o.o.cycles + 1
                    }
                },
                start: function(e) {
                    !this.isPaused() && o.transitions._slideTimeline && o.transitions.layers.timeline.state.finished && this.changeTo(o.slides.next.index)
                },
                stop: function() {
                    o.functions.setStates(this, {
                        running: !1,
                        paused: !0
                    })
                },
                changeTo: function(s, a, r) {
                    if (!document.body.contains(t)) return !1;
                    if (o.slides.current.index === s) return !1;
                    if (!this.firstStart && o.api.hasEvent("slideChangeWillStart")) {
                        var n = i.triggerHandler("slideChangeWillStart", o.api.eventData());
                        if (!1 === n) return;
                        e.isNumeric(n) && (s = parseInt(n))
                    }
                    s > o.slides.count || s < 1 ? o.debugMode && (o.debug.add("group", "slideshow"), o.debug.add("warn", "slideshow.invalidSlideIndex", [s, o.slides.count]), o.debug.groupEnd()) : o.slider.isBusy() || o.slideshow.state.pausedByVideo && !a ? !o.slider.state.preloadingImages && o.slider.state.animatingSlides && o.transitions._slideTransition && (o.slideshow.should.change = !0, o.transitions._slideTransition.progress(1), o.transitions._forceLayersOut && o.transitions._forceLayersOut.progress(1)) : (o.functions.setStates(o.transitions.layers.timeline, {
                        finished: !1
                    }), o.slideshow.should.change = !1, o.debugMode && o.debug.add("group", "slideshow"), a ? ("prev" === o.navigation.direction && o.o.twoWaySlideshow && (o.slideshow.direction = "prev"), o.debugMode && (o.debug.add("log", "slideshow.changedByUser", !1), o.o.twoWaySlideshow && o.debug.add("log", "slideshow.setdir", o.slideshow.direction))) : o.navigation.direction = o.slideshow.direction, o.transitions.timers.reverse(), o.media.stop(!0), o.slides.set.nextSlideIndex(s), o.debugMode && (o.debug.add("log", "slideshow.change", [o.slides.current.index, o.slides.next.index, o.slideshow.direction, o.navigation.direction]), o.debug.groupEnd()), o.functions.setStates(this, {
                        pausedByVideo: !1
                    }), o.functions.setStates(o.slider, {
                        changingSlides: !0
                    }), o.preload.imagesOfSlide(o.slides.next.index, function() {
                        o.transitions.start()
                    }))
                },
                forceStop: function() {
                    o.navigation.stop(), e.each(o.timeouts, function(e, t) {
                        clearTimeout(o.timeouts[e])
                    }), o.transitions.timers.stop(), o.transitions._slideTimeline.stop(), o.functions.setStates(o.transitions.layers.timeline, {
                        stopped: !0,
                        running: !1
                    }), i.find("*").stop(!0, !1).dequeue()
                },
                restart: function() {
                    i.find("*").stop(), o.navigation.change(o.slides.current.index, o.slideshow.direction)
                }
            }, o.media = {
                errors: {},
                $allMediaLayers: e(),
                protocol: "http:",
                playingInCurSlide: 0,
                endedInCurSlide: 0,
                init: function() {
                    -1 != document.location.href.indexOf("https:") && (this.protocol = "https:"), o.functions.setStates(o.slider, {
                        waitingForYouTube: !1,
                        waitingForVimeo: !1
                    }), o.media.youtube.init(), o.media.vimeo.init(), o.media.html5.init()
                },
                youtube: {
                    init: function() {
                        var t = 0;
                        this.$videos = o.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 i = e(this),
                                s = i.parent(),
                                a = s.data(o.defaults.init.dataKey),
                                r = (i.attr("src") || i.attr("data-src")).replace(/&amp;/g, "&").replace("autoplay=1", "autoplay=0").replace("?", "?smart=true&"),
                                n = {
                                    $videoElement: i,
                                    videoURL: (-1 === r.indexOf("http") ? o.media.protocol : "") + r + (-1 === r.indexOf("?") ? "?" : "&") + "wmode=opaque&html5=1&enablejsapi=1&version=3&rel=0",
                                    videoThumbnailURL: o.media.protocol + "//img.youtube.com/vi/" + r.split("embed/")[1].split("?")[0] + "/" + o.o.youtubePreview
                                };
                            i.attr("id", "ls-youtube-" + ++t), a.mediaProperties = {
                                type: "youtube",
                                saved: n
                            }, o.media.setProperties(a), a.is.backgroundVideo && o.media.setBackgroundVideo(a, s), a.is.backgroundVideo || o.media.setMediaElements(s, i, n.videoURL, n.videoThumbnailURL, a)
                        }), o.media.$allMediaLayers = o.media.$allMediaLayers.add(this.$videos.parent()), this.$videos.length && (o.timeouts.loadYouTube = Math.floor(Date.now() / 1e3), window.YT || e("<script>").attr({
                            src: "https://www.youtube.com/iframe_api",
                            type: "text/javascript"
                        }).appendTo("head"), window.onYouTubeIframeAPIReady = function() {
                            window._layerSlider.globals.youTubeIsReady = !0
                        }, o.intervals.isYouTubeReady = setInterval(function() {
                            window.YT && 1 === window.YT.loaded || window._layerSlider.globals.youTubeIsReady || Math.floor(Date.now() / 1e3) - o.timeouts.loadYouTube > 3 ? (clearInterval(o.intervals.isYouTubeReady), delete o.intervals.isYouTubeReady, delete o.timeouts.loadYouTube, o.media.youtube.$videos.parent().each(function() {
                                var t = e(this),
                                    i = t.data(o.defaults.init.dataKey),
                                    s = i.mediaProperties.saved;
                                t.on("playMedia." + a + " click." + a, ".ls-vpcontainer", function() {
                                    o.media.hideThumbnail(e(this)), o.media.checkSlideshowState(t, i), o.media.removeFromTimeline(t), o.media.youtube.play(t, s.$videoElement, s.videoURL, i)
                                }).on("playBackgroundVideo." + a, function() {
                                    o.media.youtube.play(t, s.$videoElement, s.videoURL, i)
                                }).on("stopBackgroundVideo." + a, function() {
                                    o.media.youtube.stop(t, s.$videoElement, i, !0)
                                }).on("preloadBackgroundVideo." + a, function() {
                                    o.media.youtube.createPlayer(t, s.$videoElement, s.videoURL, i, !0)
                                })
                            }), o.functions.setStates(o.slider, {
                                waitingForYouTube: !1
                            })) : o.functions.setStates(o.slider, {
                                waitingForYouTube: !0
                            })
                        }, 25))
                    },
                    createPlayer: function(e, t, i, s, a) {
                        if (null !== s.mediaSettings.showinfo) switch (i = i.replace("&showinfo=0", "").replace("&showinfo=1", ""), s.mediaSettings.showinfo) {
                            case !0:
                                i += "&showinfo=1";
                                break;
                            case !1:
                                i += "&showinfo=0"
                        }
                        if (null !== s.mediaSettings.controls) switch (i = i.replace("&controls=0", "").replace("&controls=1", ""), s.mediaSettings.controls) {
                            case !0:
                                i += "&controls=1";
                                break;
                            case !1:
                                i += "&controls=0"
                        }
                        t.attr("src", i), s.mediaProperties.player = new YT.Player(t[0], {
                            events: {
                                onReady: function() {
                                    null !== s.mediaSettings.volume && s.mediaProperties.player.setVolume(s.mediaSettings.volume), a && !s.mediaProperties.shouldPlay || (s.mediaProperties.player.playVideo(), s.mediaProperties.shouldPlay = !1)
                                },
                                onStateChange: function(t) {
                                    0 === t.data && (s.is.backgroundVideo ? s.mediaProperties.player.seekTo(0) : o.media.videoEnded(e, s))
                                }
                            }
                        })
                    },
                    play: function(e, t, i, s) {
                        s.mediaProperties.player ? s.mediaProperties.player.playVideo ? s.mediaProperties.player.playVideo() : s.mediaProperties.shouldPlay = !0 : this.createPlayer(e, t, i, s)
                    },
                    stop: function(e, t, i, s) {
                        i.mediaProperties.player && (i.mediaProperties.player.pauseVideo(), s && i.mediaProperties.player.seekTo(0), i.is.backgroundVideo || o.media.showThumbnail(e.find(".ls-vpcontainer")))
                    }
                },
                vimeo: {
                    init: function() {
                        var t = this.$videos = o.slider.$hiddenWrapper.find('iframe[src*="player.vimeo"], iframe[data-src*="player.vimeo"]');
                        if (t.length) {
                            o.timeouts.loadVimeo = Math.floor(Date.now() / 1e3), o.media.$allMediaLayers = o.media.$allMediaLayers.add(t.parent());
                            var i = 0;
                            e("<script>").attr({
                                src: o.media.protocol + "//f.vimeocdn.com/js/froogaloop2.min.js",
                                type: "text/javascript"
                            }).appendTo("head"), o.intervals.isVimeoReady = setInterval(function() {
                                o.functions.setStates(o.slider, {
                                    waitingForVimeo: !0
                                }), (window.Froogaloop || Math.floor(Date.now() / 1e3) - o.timeouts.loadVimeo > 3) && (clearInterval(o.intervals.isVimeoReady), delete o.intervals.isVimeoReady, delete o.timeouts.loadVimeo, window._layerSlider.globals.vimeoIsReady = !0, s())
                            }, 25);
                            var s = function() {
                                o.media.vimeo.$videos.each(function() {
                                    var t = e(this).attr("id", "ls-vimeo-" + ++i),
                                        s = t.parent(),
                                        r = s.data(o.defaults.init.dataKey),
                                        n = (t.attr("src") || t.attr("data-src")).replace(/&amp;/g, "&").replace("autoplay=1", "autoplay=0").replace("?", "?smart=true&"),
                                        l = -1 === n.indexOf("?") ? "?" : "&",
                                        d = -1 === n.indexOf("http") ? o.media.protocol : "",
                                        u = "wmode=opaque&api=1&player_id=ls-vimeo-" + i,
                                        p = o.media.protocol + "//vimeo.com/api/v2/video/" + n.split("video/")[1].split("?")[0] + ".json?callback=?",
                                        c = d + n + l + u;
                                    r.mediaProperties = {
                                        type: "vimeo",
                                        saved: {}
                                    }, o.media.setProperties(r), r.is.backgroundVideo && o.media.setBackgroundVideo(r, s), e.getJSON(p, function(e) {
                                        r.is.backgroundVideo || o.media.setMediaElements(s, t, c, e[0].thumbnail_large, r)
                                    }), s.on("playMedia." + a + " click." + a, ".ls-vpcontainer", function() {
                                        o.media.hideThumbnail(e(this)), o.media.checkSlideshowState(s, r), o.media.removeFromTimeline(s), o.media.vimeo.play(s, t, c, r)
                                    }).on("playBackgroundVideo." + a, function() {
                                        o.media.vimeo.play(s, t, c, r)
                                    }).on("stopBackgroundVideo." + a, function() {
                                        o.media.vimeo.stop(s, t, r, !0)
                                    }).on("preloadBackgroundVideo." + a, function() {
                                        o.media.vimeo.createPlayer(s, t, c, r, !0)
                                    })
                                }), o.functions.setStates(o.slider, {
                                    waitingForVimeo: !1
                                })
                            }
                        }
                    },
                    createPlayer: function(e, t, i, s, a) {
                        if (null !== s.mediaSettings.showinfo) switch (i = i.replace("&title=0", "").replace("&title=1", "").replace("&byline=0", "").replace("&byline=1", "").replace("&portrait=0", "").replace("&portrait=1", ""), s.mediaSettings.showinfo) {
                            case !0:
                                i = i.replace("title=0", "title=1", "").replace("byline=0", "byline=1", "").replace("portrait=0", "portrait=1", "");
                                break;
                            case !1:
                                i = i.replace("title=1", "title=0", "").replace("byline=1", "byline=0", "").replace("portrait=1", "portrait=0", "")
                        }
                        t.attr("src", i);
                        var r = function() {
                            s.is.backgroundVideo ? s.mediaProperties.player.api("seekTo", 0).api("play") : o.media.videoEnded(e, s)
                        };
                        s.mediaProperties.player = $f(t[0]), s.mediaProperties.player.addEvent("ready", function() {
                            s.mediaProperties.player.addEvent("finish", r), null !== s.mediaSettings.volume && s.mediaProperties.player.api("setVolume", s.mediaSettings.volume / 100), a || s.mediaProperties.player.api("play")
                        })
                    },
                    play: function(e, t, i, s) {
                        s.mediaProperties.player ? s.mediaProperties.player.api("play") : this.createPlayer(e, t, i, s)
                    },
                    stop: function(e, t, i, s) {
                        i.mediaProperties.player && (i.mediaProperties.player.api("pause"), s && i.mediaProperties.player.api("seekTo", 0), i.is.backgroundVideo || o.media.showThumbnail(e.find(".ls-vpcontainer")))
                    }
                },
                html5: {
                    init: function() {
                        if (this.$elements = o.slider.$hiddenWrapper.find("video, audio"), o.media.$allMediaLayers = o.media.$allMediaLayers.add(this.$elements.parent()), this.$elements.length) {
                            var t = 0;
                            o.media.html5.$elements.each(function() {
                                var i = e(this).attr("id", "ls-html5-" + ++t),
                                    s = e(this).parent(),
                                    r = s.data(o.defaults.init.dataKey);
                                if (r.mediaProperties = {
                                        type: "html5",
                                        saved: {}
                                    }, o.media.setProperties(r), r.is.backgroundVideo && o.media.setBackgroundVideo(r, s), i.attr("autoplay")) {
                                    var n = i.removeAttr("autoplay").clone(!0, !0);
                                    i.remove(), i = n.appendTo(s), s.data("ls", s.data("ls") + " autoplay: true;")
                                }
                                r.is.backgroundVideo || o.media.setMediaElements(s, i, !1, !1, r), i.on("ended." + a, function() {
                                    r.is.backgroundVideo ? (i[0].currentTime = 0, i[0].play()) : o.media.videoEnded(s, r)
                                }), s.on("playMedia." + a + " click." + a, ".ls-vpcontainer", function(t) {
                                    o.media.hideThumbnail(e(this)), o.media.checkSlideshowState(s, r), o.media.removeFromTimeline(s), o.media.html5.play(s, i, r)
                                }).on("playBackgroundVideo." + a, function() {
                                    o.media.html5.play(s, i, r)
                                }).on("stopBackgroundVideo." + a, function() {
                                    o.media.html5.stop(s, i, r, !0)
                                })
                            })
                        }
                    },
                    play: function(e, t, i) {
                        null === i.mediaSettings.volume || i.mediaProperties.volumeIsSet || (t[0].volume = i.mediaSettings.volume / 100, i.mediaProperties.volumeIsSet = !0), t[0].play()
                    },
                    stop: function(e, t, i, s) {
                        t[0].pause(), s && (t[0].currentTime = 0), i.is.backgroundVideo || o.media.showThumbnail(e.find(".ls-vpcontainer"))
                    }
                },
                setBackgroundVideo: function(t, i) {
                    if (t.mediaSettings = {
                            controls: !1,
                            autoplay: !1,
                            showinfo: !1,
                            fillmode: "cover",
                            thumbnail: !1,
                            volume: t.mediaSettings.volume ? t.mediaSettings.volume : 0
                        }, i.data("ls") && -1 !== i.data("ls").indexOf("poster:") && 0 == i.children(".ls-vpcontainer").length) {
                        var s = e("<div>").addClass("ls-vpcontainer").appendTo(i),
                            a = i.data("ls").split("poster:")[1].split(";")[0].trim();
                        e("<div>").appendTo(s).addClass("ls-videopreview").attr({
                            style: "background-image: url(" + a + ")"
                        })
                    }
                },
                setProperties: function(e) {
                    e.is.mediaLayer = !0
                },
                setMediaElements: function(t, i, s, a, r) {
                    var n = e("<div>").addClass("ls-vpcontainer").appendTo(t);
                    null === r.mediaSettings.autoplay && o.o.autoPlayVideos || r.mediaSettings.autoplay ? t.addClass("ls-autoplay") : e("<div>").appendTo(n).addClass("ls-playvideo"), t.data("ls") && -1 !== t.data("ls").indexOf("poster:") && (a = t.data("ls").split("poster:")[1].split(";")[0].trim()), i.is("iframe") ? e("<div>").appendTo(n).addClass("ls-videopreview").attr({
                        style: "background-image: url(" + a + ")"
                    }) : (a || void 0 === i.attr("poster") || (a = i.attr("poster"), i.removeAttr("poster")), a && e("<div>").appendTo(n).addClass("ls-videopreview").attr({
                        style: "background-image: url(" + a + ")"
                    }))
                },
                checkSlideshowState: function(e, t) {
                    !t.is.static && o.o.autoPauseSlideshow && (o.functions.setStates(o.slideshow, {
                        pausedByVideo: !0
                    }), "auto" == o.o.autoPauseSlideshow && this.playingInCurSlide++)
                },
                hideThumbnail: function(e) {
                    e.delay(o.transitions.media.defaults.delay).fadeOut(o.transitions.media.defaults.fadeOut)
                },
                showThumbnail: function(e) {
                    e.fadeIn(o.transitions.media.defaults.fadeIn)
                },
                videoEnded: function(e, t) {
                    "auto" != o.o.autoPauseSlideshow || t.is.backgroundVideo || (t.is.static || this.endedInCurSlide++, this.endedInCurSlide == this.playingInCurSlide && 0 !== this.playingInCurSlide && (o.functions.setStates(o.slideshow, {
                        pausedByVideo: !1
                    }), o.slideshow.remainingSlideDuration = 1, o.slideshow.start()))
                },
                playIfAllowed: function(e) {
                    var t = e.data(o.defaults.init.dataKey);
                    t.is.mediaLayer && (o.device.isMobile && (i.hasClass("ls-device-is-phone") && t.elements.$outerWrapper.hasClass("ls-hide-on-phone") || i.hasClass("ls-device-is-tablet") && t.elements.$outerWrapper.hasClass("ls-hide-on-tablet")) || (null === t.mediaSettings.autoplay && o.o.autoPlayVideos || t.mediaSettings.autoplay) && e.find(".ls-vpcontainer").trigger("playMedia"))
                },
                stop: function(t) {
                    var i = this;
                    t = void 0 === t || t, o.layers.get("current,out,youtube").each(function() {
                        var s = e(this),
                            a = s.closest(".ls-layer"),
                            r = a.data(o.defaults.init.dataKey);
                        i.youtube.stop(a, s, r, t)
                    }), o.layers.get("current,out,vimeo").each(function() {
                        var s = e(this),
                            a = s.closest(".ls-layer"),
                            r = a.data(o.defaults.init.dataKey);
                        i.vimeo.stop(a, s, r, t)
                    }), o.layers.get("current,out,html5").each(function() {
                        var s = e(this),
                            a = s.closest(".ls-layer"),
                            r = a.data(o.defaults.init.dataKey);
                        i.html5.stop(a, s, r, t)
                    }), this.playingInCurSlide = 0, this.endedInCurSlide = 0
                },
                removeFromTimeline: function(e) {
                    o.transitions._slideTimeline.kill(null, e.closest(".ls-in-out")[0])
                }
            }, o.yourLogo = {
                init: function() {
                    o.o.yourLogo && (this.$element = e("<img>").addClass("ls-yourlogo").appendTo(i).attr("style", o.o.yourLogoStyle).css({
                        visibility: "hidden",
                        display: "bock"
                    }).on("load." + a, function() {
                        var t = o.yourLogo.$element ? 500 : 0;
                        o.timeouts.yourLogo = setTimeout(function() {
                            delete o.timeouts.yourLogo, o.yourLogo.$element.data("originalWidth", o.yourLogo.$element.width()), o.yourLogo.$element.data("originalHeight", o.yourLogo.$element.height()), "auto" != o.yourLogo.$element.css("left") && o.yourLogo.$element.data("originalLeft", o.yourLogo.$element[0].style.left), "auto" != o.yourLogo.$element.css("right") && o.yourLogo.$element.data("originalRight", o.yourLogo.$element[0].style.right), "auto" != o.yourLogo.$element.css("top") && o.yourLogo.$element.data("originalTop", o.yourLogo.$element[0].style.top), "auto" != o.yourLogo.$element.css("bottom") && o.yourLogo.$element.data("originalBottom", o.yourLogo.$element[0].style.bottom), !1 !== o.o.yourLogoLink && e("<a>").appendTo(i).attr("href", o.o.yourLogoLink).attr("target", o.o.yourLogoTarget).css({
                                textDecoration: "none",
                                outline: "none"
                            }).append(o.yourLogo.$element), o.yourLogo.$element.css({
                                display: "none",
                                visibility: "visible"
                            }), o.yourLogo.resize()
                        }, t)
                    }).attr("src", o.o.yourLogo))
                },
                resize: function() {
                    this.$element.css({
                        width: this.$element.data("originalWidth") * o.resize.ratio,
                        height: this.$element.data("originalHeight") * o.resize.ratio
                    }), this.$element.fadeIn(300);
                    var e = "auto",
                        t = "auto",
                        s = "auto",
                        a = "auto";
                    e = this.$element.data("originalLeft") && -1 != this.$element.data("originalLeft").indexOf("%") ? i.width() / 100 * parseFloat(this.$element.data("originalLeft")) - this.$element.width() / 2 + parseInt(i.css("padding-left")) : parseInt(this.$element.data("originalLeft")) * o.resize.ratio, t = this.$element.data("originalRight") && -1 != this.$element.data("originalRight").indexOf("%") ? i.width() / 100 * parseFloat(this.$element.data("originalRight")) - this.$element.width() / 2 + parseInt(i.css("padding-right")) : parseInt(this.$element.data("originalRight")) * o.resize.ratio, s = this.$element.data("originalTop") && -1 != this.$element.data("originalTop").indexOf("%") ? i.height() / 100 * parseFloat(this.$element.data("originalTop")) - this.$element.height() / 2 + parseInt(i.css("padding-top")) : parseInt(this.$element.data("originalTop")) * o.resize.ratio, a = this.$element.data("originalBottom") && -1 != this.$element.data("originalBottom").indexOf("%") ? i.height() / 100 * parseFloat(this.$element.data("originalBottom")) - this.$element.height() / 2 + parseInt(i.css("padding-bottom")) : parseInt(this.$element.data("originalBottom")) * o.resize.ratio, this.$element.css({
                        left: e,
                        right: t,
                        top: s,
                        bottom: a
                    })
                }
            }, o.gui = {
                navigation: {
                    init: function() {
                        o.o.navPrevNext && this.prevNext.init(), (o.o.navStartStop || o.o.navButtons) && this.bottom.init()
                    },
                    prevNext: {
                        init: function() {
                            e('<a class="ls-gui-element ls-nav-prev" aria-label="jump to the previous slide" href="#" />').on("click." + a, function(e) {
                                e.preventDefault(), i.layerSlider("prev")
                            }).appendTo(i), e('<a class="ls-gui-element ls-nav-next" aria-label="jump to the next slide" href="#" />').on("click." + a, function(e) {
                                e.preventDefault(), i.layerSlider("next")
                            }).appendTo(i), o.o.hoverPrevNext && this.setHover()
                        },
                        setHover: function() {
                            i.find(".ls-nav-prev, .ls-nav-next").css({
                                display: "none"
                            }), i.on("mouseenter." + a, function() {
                                o.gui.navigation.forceHide || i.find(".ls-nav-prev, .ls-nav-next").stop(!0, !0).fadeIn(300)
                            }).on("mouseleave." + a, function() {
                                i.find(".ls-nav-prev, .ls-nav-next").stop(!0, !0).fadeOut(300)
                            })
                        }
                    },
                    bottom: {
                        init: function() {
                            this.wrapper = e('<div class="ls-gui-element ls-bottom-nav-wrapper" />').appendTo(i), o.o.navButtons && "always" != o.o.thumbnailNavigation && this.bullets.init(), o.o.navStartStop ? this.createStartStop() : "always" != o.o.thumbnailNavigation && this.createSides(), o.o.hoverBottomNav && "always" != o.o.thumbnailNavigation && this.setHover(), "always" == o.o.thumbnailNavigation && (this.wrapper.addClass("ls-above-thumbnails"), this.thumbnails.init())
                        },
                        bullets: {
                            init: function() {
                                var t = this;
                                e('<span class="ls-bottom-slidebuttons" />').appendTo(i.find(".ls-bottom-nav-wrapper"));
                                for (var s = 0; s < o.slides.count; s++) {
                                    var r = e('<a href="#" aria-label="jump to slide ' + (s + 1) + '" />').appendTo(i.find(".ls-bottom-slidebuttons")).data("index", s + 1).on("click." + a, function(t) {
                                        t.preventDefault(), i.layerSlider(e(this).data("index"))
                                    });
                                    "hover" == o.o.thumbnailNavigation && r.on("mouseenter." + a, function() {
                                        var s = e(this);
                                        i.find(".ls-thumbnail-hover-img").css({
                                            left: parseInt(t.hoverWrapper.css("padding-left")),
                                            top: parseInt(t.hoverWrapper.css("padding-top"))
                                        }), t.hoverImage.on("load." + a, function() {
                                            0 === e(this).width() ? t.hoverImage.css({
                                                position: "relative",
                                                margin: "0 auto",
                                                left: "auto"
                                            }) : t.hoverImage.css({
                                                position: "absolute",
                                                marginLeft: -e(this).width() / 2,
                                                left: "50%"
                                            }), t.hoverImage.css("display", "none").stop(!0, !0).fadeIn(250)
                                        }).attr("src", o.slides[s.data("index")].data.thumbnail), t.hoverWrapper.css({
                                            display: "block"
                                        }).stop().animate({
                                            left: e(this).position().left + (e(this).width() - t.hoverWrapper.outerWidth()) / 2
                                        }, 250), t.hoverWrapperInner.css({
                                            display: "none",
                                            visibility: "visible"
                                        }).stop().fadeIn(250)
                                    }).on("mouseleave." + a, function() {
                                        t.hoverWrapperInner.stop().fadeOut(250, function() {
                                            t.hoverWrapper.css({
                                                visibility: "hidden",
                                                display: "block"
                                            })
                                        })
                                    })
                                }
                                t.set.active(o.slides.first.index), "hover" == o.o.thumbnailNavigation && t.set.hover()
                            },
                            set: {
                                active: function(e) {
                                    void 0 === e && (e = o.slides.current.index), e--, i.find(".ls-bottom-slidebuttons a").removeClass("ls-nav-active"), i.find(".ls-bottom-slidebuttons a:eq( " + e + " )").addClass("ls-nav-active")
                                },
                                hover: function() {
                                    var t = o.gui.navigation.bottom.bullets,
                                        s = e('<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(i.find(".ls-bottom-slidebuttons"));
                                    i.find(".ls-thumbnail-hover, .ls-thumbnail-hover-img").css({
                                        width: o.o.tnWidth,
                                        height: o.o.tnHeight
                                    }), t.hoverWrapper = i.find(".ls-thumbnail-hover"), t.hoverImage = t.hoverWrapper.find("img").css({
                                        height: o.o.tnHeight
                                    }), t.hoverWrapperInner = i.find(".ls-thumbnail-hover-inner").css({
                                        visibility: "hidden",
                                        display: "block"
                                    }), s.appendTo(i.find(".ls-bottom-slidebuttons"))
                                }
                            }
                        },
                        createStartStop: function() {
                            this.buttonStart = e('<a class="ls-nav-start" aria-label="start slideshow" href="#" />').on("click." + a, function(e) {
                                e.preventDefault(), i.layerSlider("start")
                            }).prependTo(i.find(".ls-bottom-nav-wrapper")), this.buttonStop = e('<a class="ls-nav-stop" aria-label="stop slideshow" href="#" />').on("click." + a, function(e) {
                                e.preventDefault(), i.layerSlider("stop")
                            }).appendTo(i.find(".ls-bottom-nav-wrapper")), o.o.autoStart ? this.setStartStop("start") : this.setStartStop("stop")
                        },
                        setStartStop: function(e) {
                            if (o.o.navStartStop) switch (e) {
                                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() {
                            e('<span class="ls-nav-sides ls-nav-sideleft" />').prependTo(i.find(".ls-bottom-nav-wrapper")), e('<span class="ls-nav-sides ls-nav-sideright" />').appendTo(i.find(".ls-bottom-nav-wrapper"))
                        },
                        setHover: function() {
                            var e = this;
                            e.wrapper.css({
                                display: "none"
                            }), i.on("mouseenter." + a, function() {
                                o.gui.navigation.forceHide || e.wrapper.stop(!0, !0).fadeIn(300)
                            }).on("mouseleave." + a, function() {
                                e.wrapper.stop(!0, !0).fadeOut(300)
                            })
                        },
                        switchHelper: function(e) {
                            if (o.o.hoverBottomNav && !i.hasClass("ls-hover")) switch (e) {
                                case "on":
                                    o.gui.navigation.bottom.thumbnails.wrapper.css({
                                        visibility: "hidden",
                                        display: "block"
                                    });
                                    break;
                                case "off":
                                    o.gui.navigation.bottom.thumbnails.wrapper.css({
                                        visibility: "visible",
                                        display: "none"
                                    })
                            }
                        },
                        thumbnails: {
                            init: function() {
                                var t = this;
                                this.wrapper = e('<div class="ls-gui-element ls-thumbnail-wrapper"></div>').appendTo(i), e('<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 = i.find(".ls-thumbnail-slide-container"), "ontouchstart" in window ? this.$element.addClass("ls-touchscroll") : this.$element.on("mouseenter." + a, function() {
                                    e(this).addClass("ls-thumbnail-slide-hover")
                                }).on("mouseleave." + a, function() {
                                    e(this).removeClass("ls-thumbnail-slide-hover"), o.gui.navigation.bottom.thumbnails.scroll()
                                }).on("mousemove." + a, function(t) {
                                    var i = parseInt(t.pageX - e(this).offset().left) / e(this).width() * (e(this).width() - e(this).find(".ls-thumbnail-slide").width());
                                    e(this).find(".ls-thumbnail-slide").stop().css({
                                        marginLeft: i
                                    })
                                });
                                for (var s = 0; s < o.slides.count; s++) {
                                    var r = s + 1,
                                        n = e('<a href="#" class="ls-thumb-' + (s + 1) + '"  aria-label="jump to slide ' + (s + 1) + '"><img src="' + o.slides[r].data.thumbnail + '"></a>');
                                    o.slides[r].data.tnAlt && n.find("img").attr("alt", o.slides[r].data.tnAlt), n.data("index", r).on("click." + a, function(t) {
                                        t.preventDefault(), i.layerSlider(e(this).data("index"))
                                    }).appendTo(i.find(".ls-thumbnail-slide")), "ontouchstart" in window || n.on("mouseenter." + a, function() {
                                        e(this).children().stop().fadeTo(300, o.o.tnActiveOpacity / 100)
                                    }).on("mouseleave." + a, function() {
                                        e(this).children().hasClass("ls-thumb-active") || e(this).children().stop().fadeTo(300, o.o.tnInactiveOpacity / 100)
                                    })
                                }
                                o.gui.navigation.bottom.buttonStart && o.gui.navigation.bottom.buttonStop && (o.gui.navigation.bottom.wrapper = e('<div class="ls-bottom-nav-wrapper ls-below-thumbnails"></div>').appendTo(i), o.gui.navigation.bottom.buttonStart.clone().on("click." + a, function(e) {
                                    e.preventDefault(), i.layerSlider("start")
                                }).appendTo(o.gui.navigation.bottom.wrapper), o.gui.navigation.bottom.buttonStop.clone().on("click." + a, function(e) {
                                    e.preventDefault(), i.layerSlider("stop")
                                }).appendTo(o.gui.navigation.bottom.wrapper)), o.o.hoverBottomNav && t.setHover()
                            },
                            setHover: function() {
                                var e = this;
                                e.wrapper.css("display", "none"), o.gui.navigation.bottom.wrapper && (o.gui.navigation.bottom.wrapper = "block" == o.gui.navigation.bottom.wrapper.css("display") ? o.gui.navigation.bottom.wrapper : i.find(".ls-above-thumbnails"), o.gui.navigation.bottom.wrapper.css("display", "none")), i.on("mouseenter." + a, function() {
                                    i.addClass("ls-hover"), o.gui.navigation.forceHide || (e.wrapper.stop(!0, !0).fadeIn(300), o.gui.navigation.bottom.wrapper && o.gui.navigation.bottom.wrapper.stop(!0, !0).fadeIn(300))
                                }).on("mouseleave." + a, function() {
                                    i.removeClass("ls-hover"), e.wrapper.stop(!0, !0).fadeOut(300), o.gui.navigation.bottom.wrapper && o.gui.navigation.bottom.wrapper.stop(!0, !0).fadeOut(300)
                                })
                            },
                            change: function(t) {
                                var s = t || o.slides.next.index;
                                i.find(".ls-thumbnail-slide a:not(.ls-thumb-" + s + " )").children().each(function() {
                                    e(this).removeClass("ls-thumb-active").stop().fadeTo(750, o.o.tnInactiveOpacity / 100)
                                }), i.find(".ls-thumbnail-slide a.ls-thumb-" + s).children().addClass("ls-thumb-active").stop().fadeTo(750, o.o.tnActiveOpacity / 100)
                            },
                            scroll: function() {
                                if (!i.find(".ls-thumbnail-slide-container").hasClass("ls-thumbnail-slide-hover")) {
                                    var e = !!i.find(".ls-thumb-active").length && i.find(".ls-thumb-active").parent();
                                    if (e) {
                                        var t = e.position().left + e.width() / 2,
                                            s = i.find(".ls-thumbnail-slide-container").width() / 2 - t;
                                        s = (s = s < i.find(".ls-thumbnail-slide-container").width() - i.find(".ls-thumbnail-slide").width() ? i.find(".ls-thumbnail-slide-container").width() - i.find(".ls-thumbnail-slide").width() : s) > 0 ? 0 : s, i.find(".ls-thumbnail-slide").animate({
                                            marginLeft: s
                                        }, 600)
                                    }
                                }
                            },
                            resize: function() {
                                o.gui.navigation.bottom.switchHelper("on");
                                var e = -1 == o.slider.initial.width.indexOf("%") ? parseInt(o.slider.initial.originalWidth) : i.width(),
                                    t = i.find(".ls-thumbnail"),
                                    s = -1 == o.o.tnContainerWidth.indexOf("%") ? parseInt(o.o.tnContainerWidth) : parseInt(e / 100 * parseInt(o.o.tnContainerWidth));
                                i.find(".ls-thumbnail-slide a").css({
                                    width: parseInt(o.o.tnWidth * o.resize.ratio),
                                    height: parseInt(o.o.tnHeight * o.resize.ratio)
                                }), i.find(".ls-thumbnail-slide a:last").css({
                                    margin: 0
                                }), i.find(".ls-thumbnail-slide").css({
                                    height: parseInt(o.o.tnHeight * o.resize.ratio)
                                }), t.css({
                                    width: s * Math.floor(100 * o.resize.ratio) / 100
                                }), t.width() > i.find(".ls-thumbnail-slide").width() && t.css({
                                    width: i.find(".ls-thumbnail-slide").width()
                                }), o.gui.navigation.bottom.switchHelper("off")
                            }
                        }
                    }
                },
                skin: {
                    load: function() {
                        i.addClass("ls-" + o.o.skin);
                        var t, s = o.o.skinsPath + o.o.skin + "/skin.css",
                            r = e(e("head").length ? "head" : "body");
                        e('link[href="' + s + '"]').length ? (t = e('link[href="' + s + '"]'), o.gui.skin.isLoaded || (o.gui.skin.isLoaded = !0, o.timeouts.skinLoad1 = setTimeout(function() {
                            delete o.timeouts.skinLoad1, o.slider.init()
                        }, 150))) : document.createStyleSheet ? (document.createStyleSheet(s), t = e('link[href="' + s + '"]')) : t = e('<link rel="stylesheet" href="' + s + '" type="text/css" />').appendTo(r), t.on("load." + a, function() {
                            o.gui.skin.isLoaded || (o.gui.skin.isLoaded = !0, o.timeouts.skinLoad2 = setTimeout(function() {
                                delete o.timeouts.skinLoad2, o.slider.init()
                            }, 150))
                        }), e(window).on("load." + a, function() {
                            o.gui.skin.isLoaded || (o.gui.skin.isLoaded = !0, o.timeouts.skinLoad3 = setTimeout(function() {
                                delete o.timeouts.skinLoad3, o.slider.init()
                            }, 150))
                        }), o.timeouts.skinLoad4 = setTimeout(function() {
                            o.gui.skin.isLoaded || (o.gui.skin.isLoaded = !0, delete o.timeouts.skinLoad4, o.slider.init())
                        }, 1e3)
                    }
                },
                shadow: {
                    init: function() {
                        this.set(), this.resize()
                    },
                    set: function() {
                        this.$element = e('<div class="ls-gui-element ls-shadow"></div>').appendTo(i), "block" != this.$element.css("display") || this.$element.find("img").length || (this.show = function() {
                            o.gui.shadow.$element.css({
                                display: "none",
                                visibility: "visible"
                            }).fadeIn(500, function() {
                                o.gui.shadow.show = !1
                            })
                        }, this.image = e("<img>").attr("src", o.o.skinsPath + o.o.skin + "/shadow.png").appendTo(this.$element), this.btmMod = "number" == typeof parseInt(i.css("padding-bottom")) ? parseInt(i.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
                        }) : o.timeouts.resizeShadow = setTimeout(function() {
                            delete o.timeouts.resizeShadow, o.gui.shadow.resize()
                        }, 50))
                    }
                },
                timers: {
                    init: function() {
                        o.o.showBarTimer && this.bar.create(), o.o.showCircleTimer && this.circle.create();
                        var t = !1;
                        (t = o.o.showSlideBarTimer ? e("<div>").insertAfter(i) : e('[data-slidebar-for="' + i.attr("id") + '"], [data-slidebar-for="' + a + '"]')).length && (t.addClass("ls-gui-element"), this.slidebar.create(t))
                    },
                    bar: {
                        create: function() {
                            this.$element = e("<div>").addClass("ls-gui-element ls-bar-timer").appendTo(i)
                        }
                    },
                    circle: {
                        create: function() {
                            this.$element = e("<div>").addClass("ls-gui-element ls-circle-timer").appendTo(i), this.$element.append(e('<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(t) {
                            var s, r = e(document),
                                n = this,
                                l = function(e, t) {
                                    (s = (e.pageX ? e.pageX : o.device.touchX) - n.$element[t].offset().left - n.sliderContainerElementWidth[t] / 2) < 0 && (s = 0), s > n.containerElementWidth[t] - n.sliderContainerElementWidth[t] && (s = "calc( 100% - " + o.gui.timers.slidebar.sliderContainerElementWidth[t] + "px )"), n.$sliderContainerElement[t].css({
                                        left: s
                                    }), o.transitions._slideTimeline && o.transitions._slideTimeline.progress("string" == typeof s ? o.transitions.layers.timeline.progress : s / (n.containerElementWidth[t] - n.sliderContainerElementWidth[t]) * o.transitions.layers.timeline.progress)
                                },
                                d = function(t, i) {
                                    e(document).off("mousemove." + a), e("body").prop("unselectable", !1).removeClass("ls-unselectable"), o.o.pauseLayers && !o.slideshow.state.running || o.slider.isPaused || !o.transitions._slideTimeline || o.o.playByScroll || (!0 === o.transitions.layers.timeline.state.started ? o.transitions.layers.timeline.resume() : o.transitions.layers.timeline.play())
                                };
                            e.each(t, function(t, i) {
                                n.$containerElement[t] = e(i).addClass("ls-slidebar-container " + a), n.$element[t] = e("<div>").addClass("ls-slidebar").appendTo(n.$containerElement[t]), n.$progressBarElement[t] = e("<div>").addClass("ls-progressbar").appendTo(n.$element[t]), n.$sliderContainerElement[t] = e("<div>").addClass("ls-slidebar-slider-container").appendTo(n.$containerElement[t]), n.$sliderElement[t] = e("<div>").addClass("ls-slidebar-slider").appendTo(n.$sliderContainerElement[t]), n.sliderContainerElementWidth[t] = n.$sliderContainerElement[t].width(), n.$sliderContainerElement[t].css({
                                    marginTop: -n.$sliderElement[t].outerHeight() / 2
                                }), n.$containerElement[t].on("touchmove." + a, function(e) {
                                    l(e, t)
                                }), n.$containerElement[t].on("mousedown." + a + " touchstart." + a, function(i) {
                                    o.transitions.layers.timeline.pause(0), e("body").prop("unselectable", !0).addClass("ls-unselectable"), e(document).on("mousemove." + a, function(e) {
                                        l(e, t)
                                    }), l(i, t)
                                }), r = r.add(n.$sliderElement[t])
                            }), r.on("mouseup." + a + "touchend." + a, function(t) {
                                e(t.target).closest(i).length || (o.transitions._slideTimeline && o.transitions.layers.timeline.state.finished && o.transitions._slideTimeline.progress() !== o.transitions.layers.timeline.progress && o.functions.setStates(o.transitions.layers.timeline, {
                                    finished: !1
                                }), d())
                            })
                        }
                    }
                },
                loadingIndicator: {
                    init: function() {
                        this.$element = e("<div>").css({
                            display: "none"
                        }).addClass("ls-gui-element ls-loading-container").appendTo(i), e("<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)
                    }
                }
            }, o.navigation = {
                direction: "next",
                init: function() {
                    o.slides.count > 1 && (this.set.keyboard(), this.set.touch())
                },
                set: {
                    keyboard: function() {
                        o.o.keybNav && e("body").on("keydown." + a, function(e) {
                            o.slider.isAnimating || o.slider.isPreloading || (37 == e.which ? o.navigation.prev() : 39 == e.which && o.navigation.next())
                        })
                    },
                    touch: function() {
                        "ontouchstart" in window && o.o.touchNav && (o.slider.$innerWrapper.on("touchstart." + a, function(e) {
                            var t = e.touches ? e.touches : e.originalEvent.touches;
                            1 == t.length && (o.device.touchStartX = o.device.touchEndX = t[0].clientX)
                        }), o.slider.$innerWrapper.on("touchmove." + a, function(e) {
                            var t = e.touches ? e.touches : e.originalEvent.touches;
                            1 == t.length && (o.device.touchEndX = t[0].clientX), Math.abs(o.device.touchStartX - o.device.touchEndX) > 45 && e.preventDefault()
                        }), o.slider.$innerWrapper.on("touchend." + a, function(e) {
                            Math.abs(o.device.touchStartX - o.device.touchEndX) > 45 && (o.device.touchStartX - o.device.touchEndX > 0 ? i.layerSlider("touchNext") : i.layerSlider("touchPrev"))
                        }))
                    }
                },
                prev: function() {
                    (!o.slider.isPopup || o.slider.isPopup && o.slider.state.popupIsVisible) && (this.direction = "prev", this.forceDirection = "prev", o.slideshow.set.prevNext("prev"))
                },
                next: function() {
                    (!o.slider.isPopup || o.slider.isPopup && o.slider.state.popupIsVisible) && (this.direction = "next", this.forceDirection = "next", o.slideshow.set.prevNext("next"))
                },
                start: function() {
                    o.functions.setStates(o.slideshow, {
                        running: !0,
                        paused: !1
                    }), !0 === o.slideshow.state.pausedByLastCycle && o.functions.setStates(o.slideshow, {
                        pausedByLastCycle: !1
                    }), o.gui.navigation.bottom.setStartStop("start"), o.slideshow.state.pausedByHover || 1 !== o.transitions._slideTimeline.timeScale() && o.transitions.layers.timeline.resume(), o.slideshow.start()
                },
                stop: function() {
                    o.gui.navigation.bottom.setStartStop("stop"), o.o.pauseLayers && o.transitions.layers.timeline.pause(), o.slideshow.stop()
                }
            }, o.preload = {
                init: function() {
                    o.slider.$hiddenWrapper.find(".ls-slide img").each(function() {
                        var t = e(this),
                            i = t[0],
                            s = {};
                        if (t.is(".ls-layer, .ls-bg")) {
                            if (i.getAttribute("width") && (s.width = i.getAttribute("width")), i.getAttribute("height") && (s.height = i.getAttribute("height")), i.sizes && (s.sizes = i.sizes), i.srcset && o.o.useSrcset) {
                                s.srcSet = i.srcset, s.curSrc = i.currentSrc;
                                var a = s.srcSet.split(",").map(function(t) {
                                    return parseInt(e.trim(t).split(" ")[1])
                                });
                                s.maxWidth = Math.max.apply(null, a)
                            }
                            t.removeAttr("width").removeAttr("height").removeAttr("sizes").removeAttr("srcset"), e.isEmptyObject(s) || (t.data(o.defaults.init.dataKey).attributes = s)
                        }
                        t.data("lazy-src") && t.data("src", t.data("lazy-src")), t.data("src") ? s.curSrc && t.data("src", s.curSrc) : t.data("src", s.curSrc ? s.curSrc : i.src), t.attr("src", "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7")
                    })
                },
                imagesOfSlide: function(t, s) {
                    if (!0 !== o.slides[t].wrapped) {
                        this.slideIndex = t, s ? (this.onCompleteCallback = s, o.functions.setStates(o.slider, {
                            preloadingImages: !0
                        }), o.gui.loadingIndicator.show()) : this.onCompleteCallback = !1, o.slider.canShow && i.css({
                            visibility: "visible"
                        }), this.preImages = [];
                        var a, r, n = this;
                        o.slider.$hiddenWrapper.find(".ls-slide:eq(" + (n.slideIndex - 1) + ") *").each(function() {
                            a = e(this), r = this;
                            var t = a.data(o.defaults.init.dataKey);
                            if (a.is("img")) {
                                a.data("src") && a.attr("src", a.data("src")), t && t.attributes && t.attributes.srcSet && o.o.useSrcset && (r.srcset = t.attributes.srcSet);
                                var i = r.src,
                                    s = !!(t && t.attributes && t.attributes.curSrc) && t.attributes.curSrc;
                                s && i !== s && a.is(".ls-bg") && (i = s, o.slides[n.slideIndex].data.$background.attr("src", i)), o.preload.preImages.push([i, a])
                            } else "none" !== a.css("background-image") && -1 !== a.css("background-image").indexOf("url") && o.preload.preImages.push([a.css("background-image").match(/url\((.*)\)/)[1].replace(/"/gi, ""), a])
                        }), o.transitions.firstSlide && o.o.globalBGImage && o.preload.preImages.push([o.o.globalBGImage, e()]), this.thumbnailsAreLoaded || this.thumbnails(), 0 === this.preImages.length ? this.onComplete() : this.start()
                    } else o.slider.shouldResize && s && (o.resize.setLayers(o.layers.get("next, bg")), o.resize.layers(s))
                },
                thumbnails: function() {
                    for (var e = o.slider.thumbnails.filter(function(e, t, i) {
                            return i.indexOf(e) == t
                        }), t = e.length, i = 0; i < t; i++)(new Image).src = e[i];
                    this.thumbnailsAreLoaded = !0
                },
                start: function() {
                    o.debugMode && (o.debug.add("group", "preload"), o.debug.add("log", "preload.info", this.slideIndex)), this.preloadedImagesCount = 0;
                    for (var e, t = this, i = function() {
                            ++t.preloadedImagesCount == t.preImages.length && (o.debugMode && o.debug.groupEnd(), t.onComplete())
                        }, s = 0; s < this.preImages.length; s++) {
                        var a = new Image;
                        a.addEventListener("error", function() {
                            o.debugMode && (e = this.src.substring(this.src.lastIndexOf("/") + 1, this.src.length), o.debug.add("warn", "preload.fail", e)), i()
                        }, !1), a.addEventListener("load", function() {
                            o.debugMode && (e = this.src.substring(this.src.lastIndexOf("/") + 1, this.src.length), o.debug.add("log", "preload.success", e)), this.originalLayer.data("preloadedWidth", this.width), this.originalLayer.data("preloadedHeight", this.height), i()
                        }, !1), a.src = this.preImages[s][0], a.originalLayer = this.preImages[s][1]
                    }
                },
                onComplete: function() {
                    var t = this;
                    this.onCompleteCallback ? (o.layers.wrap(this.slideIndex), function i() {
                        if (0 !== o.slides[t.slideIndex].$layers.length) o.timeouts.waitForWrap = setTimeout(i, 100);
                        else {
                            delete o.timeouts.waitForWrap, o.functions.setStates(o.transitions.layers.parallax, {
                                ready: !0
                            }), e(".ls-thumbnail-wrapper, .ls-nav-next, .ls-nav-prev, .ls-bottom-nav-wrapper").css({
                                visibility: "visible"
                            }), o.slides[t.slideIndex].wrapped = !0;
                            var s = !(!window._layerSlider.globals.youTubeIsReady && o.layers.get("next,in,youtube,bgvideo").length),
                                a = !(!window._layerSlider.globals.vimeoIsReady && o.layers.get("next,in,vimeo,bgvideo").length),
                                r = function() {
                                    o.gui.loadingIndicator.hide(), o.slider.shouldResize ? (o.resize.setLayers(o.layers.get("next, bg")), o.resize.layers(t.onCompleteCallback)) : t.onCompleteCallback()
                                };
                            s && a ? r() : o.intervals.waitForJSApisLoaded = setInterval(function() {
                                (s || window._layerSlider.globals.youTubeIsReady) && (a || window._layerSlider.globals.vimeoIsReady) && (clearInterval(o.intervals.waitForJSApisLoaded), delete o.intervals.waitForJSApisLoaded, r())
                            }, 50)
                        }
                    }()) : o.layers.wrap(this.slideIndex, !0), o.functions.setStates(o.slider, {
                        preloadingImages: !1
                    })
                }
            }, o.resize = {
                setLayers: function(e) {
                    this.$responsiveLayers = e.add(o.layers.get("active")), o.slides.next.data.$backgroundVideo.length && (this.$responsiveLayers = this.$responsiveLayers.add(o.slides.next.data.$backgroundVideo))
                },
                all: function() {
                    if (!document.body.contains(t)) return !1;
                    o.api.hasEvent("sliderWillResize") && i.triggerHandler("sliderWillResize", o.api.eventData()), this.slider(), this.navigation(), this.layers(), this.yourLogo(), this.shadow(), this.timers(), o.transitions.layers.timeline.shouldRestart && o.o.allowRestartOnResize && (o.functions.resetSlideTimelines(), o.transitions.layers.timeline.create(!0)), o.api.hasEvent("sliderDidResize") && i.triggerHandler("sliderDidResize", o.api.eventData())
                },
                viewport: function() {
                    e(window).scrollTop(Math.round(o.slider.offsetTop) - (o.device.viewportHeight - o.slider.height) / 2)
                },
                slider: function() {
                    if (!document.body.contains(t)) return !1;
                    var s, a = o.slider.$parentWithNumericWidthValue ? o.slider.$parentWithNumericWidthValue : o.functions.getSliderClosestParentElementWidthNumericValueOfProperty("width"),
                        r = o.slider.initial,
                        n = o.slider.$parentWithNumericWidthValuePercent ? a.width() / 100 * o.slider.$parentWithNumericWidthValuePercent : a.width(),
                        l = r.type,
                        d = 0 !== r.maxWidth ? r.maxWidth : n,
                        u = "auto" === r.marginLeft ? 0 : r.marginLeft,
                        p = "auto" === r.marginRight ? 0 : r.marginRight;
                    if (o.slider.state.inFullscreen ? i[0].style.maxWidth = "" : 0 !== r.maxWidth && (i[0].style.maxWidth = r.maxWidth + "px"), -1 !== d.indexOf("%") && (d = n / 100 * parseInt(d)), (n -= u + p) > d && d >= 0 && (n = d), o.o.fitScreenWidth && ("fullwidth" === l || "fullsize" === l && "fitheight" !== o.o.fullSizeMode && "fitwidth" !== o.o.fullSizeMode)) {
                        i.parent();
                        var c = a.offset().left,
                            h = parseInt(a.css("padding-left")) || 0,
                            m = parseInt(a.css("border-left-width")) || 0;
                        i[0].style.maxWidth = "none", i[0].style.marginLeft = -(c + h + m) + "px", n = o.device.viewportWidth || e(window).width()
                    }
                    switch (n -= r.skinWidth, o.slider.state.inFullscreen && (n = o.device.width), l) {
                        case "responsive":
                            o.slider.state.inFullscreen ? (o.device.ratio > r.ratio ? this.ratio = o.device.height / r.height : this.ratio = o.device.width / r.width, n = Math.round(r.width * this.ratio), s = Math.round(r.height * this.ratio)) : (this.ratio = n / r.width, s = Math.round(r.height * this.ratio));
                            break;
                        case "fullwidth":
                            n < o.o.responsiveUnder ? (this.ratio = n / o.o.responsiveUnder, s = Math.round(r.height * this.ratio)) : o.slider.state.inFullscreen ? o.device.ratio > r.layersWidth / r.height ? (this.ratio = o.device.height / r.height, s = o.device.height) : (this.ratio = o.device.width / r.layersWidth, s = r.height * this.ratio) : (this.ratio = 1, s = r.height);
                            break;
                        case "fullsize":
                            switch (o.o.fullSizeMode.toLowerCase()) {
                                case "normal":
                                    s = o.device.viewportHeight - r.skinHeight;
                                    break;
                                case "hero":
                                    s = o.device.viewportHeight - r.skinHeight, o.slider.state.inFullscreen || (s -= o.slider.heroTop ? o.slider.heroTop : o.slider.offsetTop);
                                    break;
                                case "fitheight":
                                    n = i.parent().width() - r.skinWidth, s = i.parent().height() - r.skinHeight;
                                    break;
                                case "fitwidth":
                                    n = i.parent().width() - r.skinWidth, s = o.device.viewportHeight - r.skinHeight
                            }
                            n / s < r.ratio ? this.ratio = n / r.layersWidth : this.ratio = s / r.layersHeight;
                            break;
                        case "fixed":
                        case "fixedsize":
                            this.ratio = 1, n = r.width, s = r.height, o.o.maxRatio = 1, t.style.maxWidth = "none"
                    }
                    this.ratio = o.o.maxRatio && o.o.maxRatio > 0 && this.ratio > o.o.maxRatio ? o.o.maxRatio : this.ratio, t.style.width = n + "px", t.style.height = s + "px", o.slider.width = n, o.slider.height = s;
                    var f = i.offset();
                    o.slider.offsetX = f.left, o.slider.offsetY = f.top, o.device.isMobile ? o.device.viewportWidth < 1025 && o.device.viewportWidth > 767 ? i.removeClass("ls-device-is-phone").addClass("ls-device-is-tablet") : o.device.viewportWidth < 768 && i.removeClass("ls-device-is-tablet").addClass("ls-device-is-phone") : i.removeClass("ls-device-is-phone ls-device-is-tablet").addClass("ls-device-is-desktop")
                },
                borderRadius: function(t) {
                    for (var i = ("" + t).split(" "), s = "", a = o.o.maxRatio && o.o.maxRatio > 0 && this.ratio > o.o.maxRatio ? o.o.maxRatio : this.ratio, r = 0, n = i.length; r < n; r++) - 1 === i[r].indexOf("%") ? s += Math.ceil(parseInt(i[r]) * a) + "px " : s += i[r] + " ";
                    return e.trim(s)
                },
                layers: function(t) {
                    if (this.$responsiveLayers) {
                        o.debugMode && o.debug.add("group", "resize");
                        var i = this,
                            s = this.ratio,
                            a = this.$responsiveLayers,
                            r = o.slider.initial,
                            n = o.slider.width,
                            l = o.slider.height,
                            d = n / l,
                            u = [],
                            p = [],
                            c = [],
                            h = [],
                            m = 0,
                            f = 0,
                            g = "responsive" === r.type && -1 !== o.o.maxRatio ? r.width : r.layersWidth,
                            v = "responsive" === r.type && -1 !== o.o.maxRatio ? r.height : r.layersHeight;
                        "fullsize" === r.type || "fullwidth" === r.type || "responsive" === r.type ? (m = g > 0 ? (n - g * s) / 2 : 0, f = v > 0 ? (l - v * s) / 2 : 0) : (m = m < 0 ? 0 : m, f = f < 0 ? 0 : f);
                        for (var y = 0, b = a.length; y < b; y++) {
                            var S, w, x, T = e(a[y]),
                                C = (a[y], T.data(o.defaults.init.dataKey)),
                                k = C.original,
                                I = "fixed" === C.settings.position,
                                O = I ? 0 : m,
                                L = I ? 0 : f,
                                $ = {
                                    width: I && 0 !== k.percentWidth ? n / 100 * k.percentWidth : k.width * s,
                                    height: I && 0 !== k.percentHeight ? l / 100 * k.percentHeight : k.height * s,
                                    paddingLeft: k.paddingLeft * s,
                                    paddingTop: k.paddingTop * s,
                                    paddingRight: k.paddingRight * s,
                                    paddingBottom: k.paddingBottom * s,
                                    borderLeftWidth: Math.ceil(k.borderLeftWidth * s),
                                    borderTopWidth: Math.ceil(k.borderTopWidth * s),
                                    borderRightWidth: Math.ceil(k.borderRightWidth * s),
                                    borderBottomWidth: Math.ceil(k.borderBottomWidth * s),
                                    borderRadius: this.borderRadius(k.borderRadius)
                                },
                                B = {
                                    marginLeft: k.marginLeft * s,
                                    marginTop: k.marginTop * s
                                },
                                P = {},
                                W = {
                                    borderRadius: $.borderRadius
                                };
                            if (I && (k.percentHeight || k.percentWidth) && C.is.imageLayer && (k.percentHeight && !k.percentWidth && ($.width = k.width * ($.height / k.height)), k.percentWidth && !k.percentHeight && ($.height = k.height * ($.width / k.width))), ("number" == typeof k.width && k.width < 0 || "auto" == k.width) && o.debugMode && o.debug.add("warn", "resize.width", [y + 1, k.width]), ("number" == typeof k.height && k.height < 0 || "auto" == k.height) && o.debugMode && o.debug.add("warn", "resize.height", [y + 1, k.height]), C.is.textLayer && ($.fontSize = k.fontSize * s, o.device.isMobile && $.fontSize < C.styleSettings.minmobilefontsize ? $.fontSize = C.styleSettings.minmobilefontsize : $.fontSize < C.styleSettings.minfontsize && ($.fontSize = C.styleSettings.minfontsize), x = $.fontSize / k.fontSize, $.fontSize += "px", "normal" !== k.lineHeight && ($.lineHeight = parseFloat(k.lineHeight) * x + "px"), "normal" !== k.letterSpacing && ($.letterSpacing = parseFloat(k.letterSpacing) * x + "px")), C.is.slideBackground || C.is.backgroundVideo)
                                if (C.is.slideBackground) {
                                    var M = o.slides[C.is.onSlide].data.backgroundSize;
                                    switch (S = void 0 !== M && "inherit" !== M ? M : o.o.slideBGSize, S = S.replace("100% 100%", "stretch")) {
                                        case "auto":
                                            break;
                                        case "cover":
                                            k.ratio < d ? ($.width = n, $.height = $.width / k.ratio) : ($.height = l, $.width = $.height * k.ratio);
                                            break;
                                        case "contain":
                                            k.ratio < d ? ($.height = l, $.width = $.height * k.ratio) : ($.width = n, $.height = $.width / k.ratio);
                                            break;
                                        case "stretch":
                                            $.width = n, $.height = l
                                    }
                                    $.width = Math.round($.width), $.height = Math.round($.height);
                                    var _ = o.slides[C.is.onSlide].data.backgroundPosition;
                                    switch ((w = void 0 !== _ ? _.split(" ") : o.o.slideBGPosition.split(" "))[0]) {
                                        case "left":
                                            $.x = 0;
                                            break;
                                        case "center":
                                            $.x = (o.slider.width - $.width) / 2;
                                            break;
                                        case "right":
                                            $.x = o.slider.width - $.width;
                                            break;
                                        default:
                                            -1 !== w[0].indexOf("%") ? $.x = (o.slider.width - $.width) / 100 * parseInt(w[0]) : $.x = parseInt(w[0])
                                    }
                                    if (void 0 !== w[1]) switch (w[1]) {
                                        case "top":
                                            $.y = 0;
                                            break;
                                        case "center":
                                            $.y = (o.slider.height - $.height) / 2;
                                            break;
                                        case "bottom":
                                            $.y = o.slider.height - $.height;
                                            break;
                                        default:
                                            -1 !== w[1].indexOf("%") ? $.y = (o.slider.height - $.height) / 100 * parseInt(w[1]) : $.y = parseInt(w[1])
                                    }
                                    $.transform = "translateX(" + $.x + "px) translateY(" + $.y + "px)", $["-ms-transform"] = "translateX(" + $.x + "px) translateY(" + $.y + "px)", $["-webkit-transform"] = "translateX(" + $.x + "px) translateY(" + $.y + "px)"
                                } else C.is.backgroundVideo && (k.ratio < d ? ($.width = n, $.height = $.width / k.ratio) : ($.height = l, $.width = $.height * k.ratio), $.x = (o.slider.width - $.width) / 2, $.y = (o.slider.height - $.height) / 2, $.width = Math.round($.width), $.height = Math.round($.height), $.transform = "translateX(" + $.x + "px) translateY(" + $.y + "px)", $["-ms-transform"] = "translateX(" + $.x + "px) translateY(" + $.y + "px)", $["-webkit-transform"] = "translateX(" + $.x + "px) translateY(" + $.y + "px)");
                            else {
                                if (C.mediaSettings.fullsize) switch (C.mediaSettings.fillmode) {
                                    default:
                                        case "cover":
                                        k.ratio < d ? ($.width = n, $.height = $.width / k.ratio) : ($.height = l, $.width = $.height * k.ratio);
                                    break;
                                    case "contain":
                                            k.ratio > d ? ($.width = n, $.height = $.width / k.ratio) : ($.height = l, $.width = $.height * k.ratio)
                                }
                                $.outerWidth = $.width + $.paddingLeft + $.paddingRight + $.borderLeftWidth + $.borderRightWidth, $.outerHeight = $.height + $.paddingTop + $.paddingBottom + $.borderTopWidth + $.borderBottomWidth, B.width = P.width = $.outerWidth, B.height = P.height = $.outerHeight, -1 != k.left.indexOf("%") ? "100%" === k.left ? $.left = 0 === O ? o.slider.width / 100 * parseFloat(k.left) - $.outerWidth : O + g * s / 100 * parseFloat(k.left) - $.outerWidth : "0%" === k.left ? $.left = 0 === O ? 0 : O : $.left = 0 === O ? o.slider.width / 100 * parseFloat(k.left) - $.outerWidth / 2 : O + g * s / 100 * parseFloat(k.left) - $.outerWidth / 2 : $.left = O + parseFloat(k.left) * s, B.left = $.left, -1 != k.top.indexOf("%") ? "100%" === k.top ? $.top = 0 === L ? o.slider.height / 100 * parseFloat(k.top) - $.outerHeight : L + v * s / 100 * parseFloat(k.top) - $.outerHeight : "0%" === k.top ? $.top = 0 === L ? 0 : L + 0 : $.top = 0 === L ? o.slider.height / 100 * parseFloat(k.top) - $.outerHeight / 2 : L + v * s / 100 * parseFloat(k.top) - $.outerHeight / 2 : $.top = L + parseFloat(k.top) * s, B.top = $.top
                            }
                            C.responsive = $, u[y] = $, C.is.slideBackground || C.is.backgroundVideo || (C.settings.wrapperData.responsive = B, p[y] = B, c[y] = P, h[y] = W)
                        }
                        for (var z = 0, F = u.length; z < F; z++) {
                            var D = e(a[z]),
                                R = D.data(o.defaults.init.dataKey);
                            D.css(u[z]), R.is.slideBackground || R.is.backgroundVideo ? (R.is.slideBackground || R.is.backgroundVideo) && (R.elements.$bgOuterWrapper.css({
                                width: o.slider.width,
                                height: o.slider.height
                            }), R.elements.$outerWrapper.css({
                                width: o.slider.width,
                                height: o.slider.height
                            })) : (D.find(".split-item").css(h[z]), i.wrappers(D, R, p[z], c[z]))
                        }
                        void 0 !== t && t(), o.debugMode && o.debug.groupEnd("resize")
                    }
                },
                wrappers: function(e, t, i, s) {
                    i && t.elements.$wrapper.css(i), s && t.loop.enabled && t.elements.$loopWrapper.css(s), r.TweenMax.set(t.elements.$wrapper[0], {
                        autoCSS: !1,
                        css: {
                            transformPerspective: t.transformPerspective.layer * o.resize.ratio
                        }
                    }), t.loop.enabled && r.TweenMax.set(t.elements.$loopWrapper[0], {
                        autoCSS: !1,
                        css: {
                            transformPerspective: t.transformPerspective.loop * o.resize.ratio
                        }
                    }), t.hover.enabled && r.TweenMax.set(e[0], {
                        autoCSS: !1,
                        css: {
                            transformPerspective: t.transformPerspective.hover * o.resize.ratio
                        }
                    }), t.textIn.nodes && r.TweenMax.set(t.textIn.nodes, {
                        autoCSS: !1,
                        css: {
                            transformPerspective: t.transformPerspective.text * o.resize.ratio
                        }
                    }), t.textOut.nodes && r.TweenMax.set(t.textOut.nodes, {
                        autoCSS: !1,
                        css: {
                            transformPerspective: t.transformPerspective.text * o.resize.ratio
                        }
                    }), t.parallax.enabled && r.TweenMax.set(t.elements.$parallaxWrapper[0], {
                        autoCSS: !1,
                        css: {
                            transformPerspective: t.transformPerspective.parallax * o.resize.ratio
                        }
                    })
                },
                transformProperties: function(e, t, i, s) {
                    if ("object" == typeof i.x) {
                        for (var a = [], r = 0; r < i.x.length; r++) "string" == typeof i.x[r] ? a[r] = this.getXY(e, i.x[r], "Width") : a[r] = i.x[r] * o.resize.ratio;
                        t.cycle.x = a
                    } else "string" == typeof i.x ? t.x = this.getXY(e, i.x, "Width") : void 0 !== i.x && (t.x = i.x * o.resize.ratio);
                    if ("object" == typeof i.y) {
                        for (var n = [], l = 0; l < i.y.length; l++) "string" == typeof i.y[l] ? n[l] = this.getXY(e, i.y[l], "Height") : n[l] = i.y[l] * o.resize.ratio;
                        t.cycle.y = n
                    } else "string" == typeof i.y ? t.y = this.getXY(e, i.y, "Height") : void 0 !== i.y && (t.y = i.y * o.resize.ratio);
                    if (s && (t = s), "object" == typeof i.transformOrigin) {
                        for (var d = [], u = 0; u < i.transformOrigin.length; u++) d[u] = o.functions.convert.transformOrigin(i.transformOrigin[u], e);
                        t.cycle.transformOrigin = d
                    } else "string" == typeof i.transformOrigin && (t.transformOrigin = o.functions.convert.transformOrigin(i.transformOrigin, e))
                },
                styleProperties: function(t, i) {
                    void 0 !== i.width && (e.isNumeric(i.width) ? t.width = parseInt(i.width) * o.resize.ratio : "string" == typeof i.width && -1 !== i.width.indexOf("%") && (t.width = o.slider.width / 100 * parseInt(i.width))), void 0 !== i.height && (e.isNumeric(i.height) ? t.height = parseInt(i.height) * o.resize.ratio : "string" == typeof i.height && -1 !== i.height.indexOf("%") && (t.height = o.slider.height / 100 * parseInt(i.height))), i.borderRadius && (t.borderRadius = o.resize.borderRadius(i.borderRadius))
                },
                clip: function(t, i, s) {
                    i = e.trim(i.replace("rect(", "").replace(")", ""));
                    for (var a, r = t.data(o.defaults.init.dataKey).responsive, n = Math.ceil(r.outerWidth), l = Math.ceil(r.outerHeight), d = -1 === i.indexOf(",") ? i.split(" ") : i.split(","), u = "", p = 0; p < d.length; p++)
                        if (-1 !== d[p].indexOf("%")) switch (p) {
                            case 0:
                                u += parseInt(l / 100 * parseInt(d[p]) * 100) / 100 + "px ";
                                break;
                            case 1:
                                u += s ? parseInt(100 * (n - n / 100 * parseInt(d[p]))) / 100 + "px " : parseInt(n / 100 * parseInt(d[p]) * 100) / 100 + "px ";
                                break;
                            case 2:
                                u += s ? parseInt(100 * (l - l / 100 * parseInt(d[p]))) / 100 + "px " : parseInt(l / 100 * parseInt(d[p]) * 100) / 100 + "px ";
                                break;
                            case 3:
                                u += parseInt(n / 100 * parseInt(d[p]) * 100) / 100 + "px"
                        } else switch (a = parseInt(d[p]) * o.resize.ratio, p) {
                            case 0:
                                u += a + "px ";
                                break;
                            case 1:
                                u += s ? n - a + " " : a + "px ";
                                break;
                            case 2:
                                u += s ? l - a + "px " : a + "px ";
                                break;
                            case 3:
                                u += a + "px"
                        }
                        return "rect(" + u + ")"
                },
                getXY: function(e, t, i) {
                    var s = 0,
                        a = e.data(o.defaults.init.dataKey),
                        r = a.original,
                        n = a.responsive,
                        l = a.settings.wrapperData.responsive;
                    if (r && n && l) switch (t) {
                        case "left":
                            s = -1 != r.left.indexOf("%") ? "100%" === r.left ? -n.left - n.outerWidth - l.marginLeft : -parseInt(r.left) / 100 * o.slider.width - n.outerWidth / 2 - l.marginLeft : -n.left - n.outerWidth - l.marginLeft;
                            break;
                        case "right":
                            s = -1 != r.left.indexOf("%") ? "100%" === r.left ? o.slider.width - n.left - l.marginLeft : (1 - parseInt(r.left) / 100) * o.slider.width + n.outerWidth / 2 - l.marginLeft : o.slider.width - n.left - l.marginLeft;
                            break;
                        case "top":
                            s = -1 != r.top.indexOf("%") ? "100%" === r.top ? -n.top - n.outerHeight - l.marginTop : -parseInt(r.top) / 100 * o.slider.height - n.outerHeight / 2 - l.marginTop : -n.top - n.outerHeight - l.marginTop;
                            break;
                        case "bottom":
                            s = -1 != r.top.indexOf("%") ? "100%" === r.top ? o.slider.height - n.top - l.marginTop : (1 - parseInt(r.top) / 100) * o.slider.height + n.outerHeight / 2 - l.marginTop : o.slider.height - n.top - l.marginTop;
                            break;
                        case "width":
                            s = n.outerWidth;
                            break;
                        case "-width":
                            s = -n.outerWidth;
                            break;
                        case "height":
                            s = n.outerHeight;
                            break;
                        case "-height":
                            s = -n.outerHeight;
                            break;
                        default:
                            s = -1 !== t.indexOf("%") ? n["outer" + i] / 100 * parseInt(t) : -1 !== t.indexOf("sw") ? parseInt(t.split("sw")[0]) / 100 * o.slider.width : -1 !== t.indexOf("sh") ? parseInt(t.split("lw")[0]) / 100 * o.slider.height : -1 !== t.indexOf("lw") ? n.outerWidth / 100 * parseInt(t.split("lw")[0]) : -1 !== t.indexOf("lh") ? n.outerHeight / 100 * parseInt(t.split("lj")[0]) : parseInt(t) * o.resize.ratio
                    }
                    return s
                },
                navigation: function() {
                    "always" == o.o.thumbnailNavigation && o.gui.navigation.bottom.thumbnails.resize()
                },
                shadow: function() {
                    o.gui.shadow.show && o.gui.shadow.show(), o.gui.shadow.$element && o.gui.shadow.resize()
                },
                yourLogo: function() {
                    o.yourLogo.$element && o.yourLogo.resize()
                },
                timers: function() {
                    if (o.gui.timers.slidebar.$containerElement.length > 0)
                        for (var e = 0, t = o.gui.timers.slidebar.$containerElement.length; e < t; e++) o.gui.timers.slidebar.containerElementWidth[e] = o.gui.timers.slidebar.$containerElement[e].width(), o.gui.timers.slidebar.elementWidth[e] = o.gui.timers.slidebar.$element[e].width()
                }
            }, o.transitions = {
                firstSlide: !0,
                start: function() {
                    if (!document.body.contains(t)) return !1;
                    o.device.scroll.directionAtSlideTransitionStart = o.device.scroll.direction, "always" == o.o.thumbnailNavigation && (o.gui.navigation.bottom.thumbnails.change(), "ontouchstart" in window || o.gui.navigation.bottom.thumbnails.scroll()), this.layers.out.forced(), this.slide.init()
                },
                slide: {
                    $wrapper: e(),
                    init: function() {
                        var t, i;
                        if (o.functions.setStates(o.slider, {
                                animatingSlides: !0
                            }), o.transitions.layers.parallax.reset(), o.slider.$layersWrapper.children('.ls-parallax[data-ls-parallax="active"]').each(function() {
                                e(this).find(".ls-layer").data(o.defaults.init.dataKey).settings.slideOut === o.slides.current.index && e(this).attr("data-ls-parallax", "disbaled")
                            }), o.transitions.curSlide = o.slides.current, o.transitions.nextSlide = o.slides.next, o.transitions._slideTransition = new r.TimelineMax({
                                paused: !0,
                                onComplete: function() {
                                    o.transitions.slide.onComplete()
                                }
                            }), o.transitions.firstSlide) {
                            if (void 0 !== o.transitions.nextSlide.data.$background) {
                                var s = o.transitions.nextSlide.data.$background.data(o.defaults.init.dataKey),
                                    a = s.kenBurns.zoom ? s.kenBurns.from.scale : 1,
                                    n = s.kenBurns.zoom ? s.kenBurns.from.rotation : 0,
                                    l = o.transitions.nextSlide.filter.from || "none";
                                o.transitions._slideTransition.set(o.transitions.nextSlide.data.$background[0], {
                                    "-webkit-filter": l,
                                    filter: l
                                }, 0), o.transitions._slideTransition.fromTo(o.transitions.nextSlide.data.$background.closest(".ls-bg-wrap")[0], o.o.sliderFadeInDuration, {
                                    autoCSS: !1,
                                    css: {
                                        scale: a,
                                        rotation: n,
                                        opacity: 0,
                                        display: "block"
                                    }
                                }, {
                                    autoCSS: !1,
                                    css: {
                                        opacity: 1
                                    }
                                }, 0)
                            }
                            this.start(!0)
                        } else "undefined" == typeof layerSliderTransitions && "undefined" == typeof layerSliderCustomTransitions ? (this.start(!0), o.debugMode && o.debug.add("warn", "slideTransition.noSlideTransition", o.transitions.nextSlide.index)) : void 0 === o.transitions.curSlide.data.$background && void 0 === o.transitions.nextSlide.data.$background && "transparent" == o.transitions.curSlide.data.backgroundColor && "transparent" == o.transitions.nextSlide.data.backgroundColor ? this.start(!0) : ("x" === o.o.clipSlideTransition ? o.device.$overflowWrapper.addClass("ls-overflowx-hidden") : "y" === o.o.clipSlideTransition ? o.device.$overflowWrapper.addClass("ls-overflowy-hidden") : !0 === o.o.clipSlideTransition && o.device.$overflowWrapper.addClass("ls-overflow-hidden"), void 0 !== o.transitions.curSlide.data.$background && (t = o.transitions.curSlide.data.$background.closest(".ls-bg-wrap")[0]._gsTransform, (i = o.transitions.curSlide.data.$background.data(o.defaults.init.dataKey)).responsive.filter = o.transitions.curSlide.data.$background[0].style.filter, i.responsive.kbRotation = void 0 !== t ? " rotate(" + t.rotation + "deg)" : " rotate(0deg)", i.responsive.kbScale = void 0 !== t ? " scale(" + t.scaleX + ")" : " scale(1)"), o.transitions.slide.$wrapper = e("<div>").addClass("ls-slide-transition-wrapper").css({
                            width: o.slider.width,
                            height: o.slider.height
                        }), this.select.slideTransitionType())
                    },
                    select: {
                        slideTransitionType: function() {
                            o.transitions.slide.normal.select.transitionType()
                        }
                    },
                    start: function(e) {
                        var t, s = !(!o.slides.current.index || !o.slides.current.data.$backgroundVideo.length),
                            a = !(!o.slides.next.index || !o.slides.next.data.$backgroundVideo.length);
                        if (!o.slideshow.firstStart && o.api.hasEvent("slideChangeDidStart") && i.triggerHandler("slideChangeDidStart", o.api.eventData()), !e && (void 0 !== o.transitions.nextSlide.data.transitionDuration && o.transitions._slideTransition.duration(o.transitions.nextSlide.data.transitionDuration), o.debugMode && o.debug.options.transitionDuration && o.transitions._slideTransition.duration(o.debug.options.transitionDuration), o.transitions.layers.timeline.timeScaleModifier > .25)) {
                            var n = o.transitions._slideTransition.duration() / (.75 + o.transitions.layers.timeline.timeScaleModifier);
                            n = n < .5 ? .5 : n, o.transitions._slideTransition.duration(n)
                        }
                        var l, d = o.transitions._slideTransition.duration() / o.transitions._slideTransition.timeScale(),
                            u = d,
                            p = o.transitions.nextSlide.data.timeShift;
                        p > 0 ? p = 0 : p < 0 && Math.abs(p) > d && (p = -d), o.transitions.nextSlide.data.calculatedTimeShift = p, l = o.transitions.firstSlide ? o.o.sliderFadeInDuration + .01 : (u + p) * o.transitions._slideTransition.timeScale(), (s || a) && o.transitions.media.changeBackgroundVideo(o.transitions.firstSlide, !(!s || !a)), o.transitions._slideTransition.call(function() {
                            !o.slideshow.firstStart && o.api.hasEvent("slideChangeWillComplete") && i.triggerHandler("slideChangeWillComplete", o.api.eventData()), o.slideshow.should.change || o.transitions.layers.timeline.prepare(), o.media.stop(!0), o.slides.set.slideIndexes(), o.o.hashChange && (document.location.hash = o.slides[o.slides.current.index].data.deeplink || "_no-deeplink-found_"), o.slideshow.start(), !o.transitions.firstSlide && o.slides.prev.index && o.slides.prev.data.$backgroundVideo.length && !o.slides.prev.data.$backgroundVideo.data(o.defaults.init.dataKey).mediaProperties.willBePaused && (o.slides.prev.data.$backgroundVideo.trigger("stopBackgroundVideo"), o.slides.prev.data.$backgroundVideo.data(o.defaults.init.dataKey).elements.$bgWrapper.css({
                                display: "none"
                            })), o.slideshow.should.change || o.slides.next.data.$backgroundVideo.length && !o.slides.next.data.$backgroundVideo.data(o.defaults.init.dataKey).mediaProperties.isPreloaded && (o.slides.next.data.$backgroundVideo.trigger("preloadBackgroundVideo"), o.slides.next.data.$backgroundVideo.data(o.defaults.init.dataKey).mediaProperties.isPreloaded = !0), o.transitions.firstSlide = !1
                        }, [], this, l), o.transitions._slideTransition.play(), void 0 !== o.transitions.curSlide.data && void 0 !== o.transitions.curSlide.data.$background && (t = o.transitions.curSlide.data.$background.data(o.defaults.init.dataKey), o.timeouts.applyBG = setTimeout(function() {
                            delete o.timeouts.applyBG, o.transitions.curSlide.data.$background.closest(".ls-bg-wrap").hide(), t.kenBurns.zoom && r.TweenMax.set(o.transitions.curSlide.data.$background[0], {
                                autoCSS: !1,
                                css: t.kenBurns.from
                            })
                        }, 5))
                    },
                    onComplete: function() {
                        var e;
                        void 0 !== o.transitions.nextSlide.data.$background && o.transitions.nextSlide.data.$background.closest(".ls-bg-wrap").show(), "transparent" !== o.transitions.nextSlide.data.backgroundColor ? o.slider.$innerWrapper.css("background-color", o.transitions.nextSlide.data.backgroundColor) : o.slider.$innerWrapper.css("background-color", o.o.globalBGColor), o.o.leaveOverflow || o.device.$overflowWrapper.removeClass("ls-overflowx-hidden ls-overflowy-hidden ls-overflow-hidden"), this.$wrapper && (this.$wrapper.html("").remove(), this.$wrapper = !1), o.gui.navigation.bottom.bullets.set.active(), o.o.cycles > 0 && (o.slideshow.hasOwnProperty("cycleSlideIndex") ? o.slideshow.cycles.check(o.transitions.nextSlide.index) && (o.navigation.stop(), o.functions.setStates(o.slideshow, {
                            pausedByLastCycle: !0
                        }), o.o.forceCycles && (o.slideshow.curCycle = 1)) : o.slideshow.cycles.set()), o.functions.setStates(o.slider, {
                            animatingSlides: !1,
                            changingSlides: !1
                        }), !o.slideshow.firstStart && o.api.hasEvent("slideChangeDidComplete") && i.triggerHandler("slideChangeDidComplete", o.api.eventData()), o.slideshow.firstStart = !1, !1 !== o.slideshow.should.change && o.navigation.forceDirection ? (void 0 !== o.transitions.curSlide.data && void 0 !== o.transitions.curSlide.data.$background && (e = o.transitions.curSlide.data.$background.data(o.defaults.init.dataKey), o.transitions.curSlide.data.$background.closest(".ls-bg-wrap").hide(), e.kenBurns.zoom && r.TweenMax.set(o.transitions.curSlide.data.$background[0], {
                            autoCSS: !1,
                            css: e.kenBurns.from
                        })), o.slideshow.changeTo(o.slideshow.get.slideInSequence(o.navigation.forceDirection), !0)) : o.preload.imagesOfSlide(o.slides.next.index)
                    },
                    normal: {
                        select: {
                            transitionType: function() {
                                if (o.o.slideTransition) o.transitions.slide.normal.setTransition(o.o.slideTransition.type, o.o.slideTransition.obj);
                                else {
                                    var e, t, i = !!o.transitions.nextSlide.data.transition2d && o.transitions.nextSlide.data.transition2d.toString().split(",");
                                    o.device.touchPrev && o.o.slideOnSwipe ? (o.device.touchPrev = !1, this.transition("2d", "1")) : o.device.touchNext && o.o.slideOnSwipe ? (o.device.touchNext = !1, this.transition("2d", "1")) : o.slides.next.data.$background || i && (!i || -1 != i.indexOf("1") || -1 != i.indexOf("2") || -1 != i.indexOf("3") || -1 != i.indexOf("4")) ? o.browser.supports3D() && (o.transitions.nextSlide.data.transition3d || o.transitions.nextSlide.data.customtransition3d) ? o.transitions.nextSlide.data.transition3d && o.transitions.nextSlide.data.customtransition3d ? (e = Math.floor(2 * Math.random()), t = [
                                        ["3d", o.transitions.nextSlide.data.transition3d],
                                        ["custom3d", o.transitions.nextSlide.data.customtransition3d]
                                    ], this.transition(t[e][0], t[e][1])) : o.transitions.nextSlide.data.transition3d ? this.transition("3d", o.transitions.nextSlide.data.transition3d) : this.transition("custom3d", o.transitions.nextSlide.data.customtransition3d) : o.transitions.nextSlide.data.transition2d && o.transitions.nextSlide.data.customtransition2d ? (e = Math.floor(2 * Math.random()), t = [
                                        ["2d", o.transitions.nextSlide.data.transition2d],
                                        ["custom2d", o.transitions.nextSlide.data.customtransition2d]
                                    ], this.transition(t[e][0], t[e][1])) : o.transitions.nextSlide.data.transition2d ? this.transition("2d", o.transitions.nextSlide.data.transition2d) : o.transitions.nextSlide.data.customtransition2d ? this.transition("custom2d", o.transitions.nextSlide.data.customtransition2d) : this.transition("2d", "1") : this.transition("2d", "5")
                                }
                            },
                            transition: function(e, t) {
                                o.debugMode && o.debug.add("group", "slideTransition.info"), t += "";
                                var i, s = -1 == e.indexOf("custom") ? o.t : o.ct,
                                    a = "3d";
                                if (-1 != e.indexOf("2d") && (a = "2d"), -1 != t.indexOf("last")) i = s["t" + a].length - 1, "last";
                                else if (-1 != t.indexOf("all")) i = Math.floor(Math.random() * o.functions.countProp(s["t" + a])), "random from all";
                                else {
                                    var r = t.split(","),
                                        n = r.length;
                                    i = parseInt(r[Math.floor(Math.random() * n)]) - 1, "random from specified"
                                }
                                void 0 === s["t" + a][i] && (o.debugMode && o.debug.add("warn", "slideTransition.customTransition", [a.toUpperCase() + (-1 === e.indexOf("custom") ? "" : " (CUSTOM)"), i + 1]), s = o.t, e = a = "2d", i = 0), o.debugMode && o.debug.add("log", "slideTransition.info", [a.toUpperCase() + (-1 === e.indexOf("custom") ? "" : " (CUSTOM)"), i + 1, s["t" + a][i].name]), o.transitions.slide.normal.setTransition(a, s["t" + a][i])
                            }
                        },
                        setTransition: function(t, i) {
                            var s, a, n, l, d = e.extend(!0, {
                                    cols: 1,
                                    rows: 1
                                }, i),
                                u = typeof d.cols,
                                p = typeof d.rows,
                                c = [],
                                h = o.navigation.direction,
                                m = 0,
                                f = 0,
                                g = !!o.transitions.curSlide.data.$background && o.functions.getURL(o.transitions.curSlide.data.$background),
                                v = !!o.transitions.nextSlide.data.$background && o.functions.getURL(o.transitions.nextSlide.data.$background),
                                y = o.o.playByScroll && "up" === o.device.scroll.direction ? "to" : "from";
                            switch (u) {
                                case "number":
                                    u = d.cols;
                                    break;
                                case "string":
                                    u = Math.floor(Math.random() * (parseInt(d.cols.split(",")[1]) - parseInt(d.cols.split(",")[0]) + 1)) + parseInt(d.cols.split(",")[0]);
                                    break;
                                default:
                                    u = Math.floor(Math.random() * (d.cols[1] - d.cols[0] + 1)) + d.cols[0]
                            }
                            switch (p) {
                                case "number":
                                    p = d.rows;
                                    break;
                                case "string":
                                    p = Math.floor(Math.random() * (parseInt(d.rows.split(",")[1]) - parseInt(d.rows.split(",")[0]) + 1)) + parseInt(d.rows.split(",")[0]);
                                    break;
                                default:
                                    p = Math.floor(Math.random() * (d.rows[1] - d.rows[0] + 1)) + d.rows[0]
                            }
                            if (o.device.isMobile && o.o.optimizeForMobile ? (u >= 15 ? u = 7 : u >= 5 ? u = 4 : u >= 4 ? u = 3 : u > 2 && (u = 2), p >= 15 ? p = 7 : p >= 5 ? p = 4 : p >= 4 ? p = 3 : p > 2 && (p = 2), p > 2 && u > 2 && (p = 2, u > 4 && (u = 4))) : (u = u > 35 ? 35 : u, p = p > 35 ? 35 : p), o.debugMode && !o.o.slideTransition && (o.debug.add("log", "slideTransition.properties", [
                                    [u, p], u * p
                                ]), o.debug.groupEnd()), s = Math.floor(o.slider.width / u), a = Math.floor(o.slider.height / p), n = o.slider.width - s * u, l = o.slider.height - a * p, "prev" == h) {
                                var b = {
                                    random: "random",
                                    forward: "reverse",
                                    reverse: "forward",
                                    "col-forward": "col-reverse",
                                    "col-reverse": "col-forward"
                                };
                                d.tile && d.tile.sequence && (d.tile.sequence = b[d.tile.sequence]), e.each(["animation", "before", "after"], function(e, t) {
                                    if (d[t] && d[t].transition) {
                                        var i = d[t].transition;
                                        i.rotateX && Math.abs(i.rotateX) > 44 && (i.rotateX *= -1), i.rotateY && Math.abs(i.rotateY) > 44 && (i.rotateY *= -1), i.rotate && (i.rotate *= -1)
                                    }
                                })
                            }
                            for (var S = 0; S < u * p; S++) c.push(S);
                            switch (d.tile.sequence) {
                                case "reverse":
                                    c.reverse();
                                    break;
                                case "col-forward":
                                    c = o.functions.sortArray(p, u, "forward");
                                    break;
                                case "col-reverse":
                                    c = o.functions.sortArray(p, u, "reverse");
                                    break;
                                case "random":
                                    c = o.functions.shuffleArray(c)
                            }
                            if ("transparent" === o.transitions.curSlide.data.backgroundColor && (o.transitions.curSlide.data.backgroundColor = o.o.globalBGColor), "transparent" === o.transitions.nextSlide.data.backgroundColor && (o.transitions.nextSlide.data.backgroundColor = o.o.globalBGColor), "2d" == t) {
                                var w = -1 != d.name.toLowerCase().indexOf("carousel"),
                                    x = -1 != d.name.toLowerCase().indexOf("crossfad");
                                this.$curTiles = e("<div>").addClass("ls-curtiles").appendTo(o.transitions.slide.$wrapper), this.$nextTiles = e("<div>").addClass("ls-nexttiles").appendTo(o.transitions.slide.$wrapper)
                            }
                            for (var T = 0; T < u * p; T++) {
                                var C, k, I, O, L, $, B, P = (T + 1) % u == 0 ? n : 0,
                                    W = T > (p - 1) * u - 1 ? l : 0,
                                    M = e("<div>").addClass("ls-slide-transition-tile").css({
                                        width: s + P,
                                        height: a + W
                                    }).data("style", {
                                        width: s + P,
                                        height: a + W
                                    }).appendTo(o.transitions.slide.$wrapper);
                                c[T];
                                if (m = T % u == 0 ? m + 1 : m, f = T % u == 0 ? 1 : f + 1, "3d" == t) {
                                    M.addClass("ls-3d-container");
                                    var _, z, F, D, R, N, E, V = s + P,
                                        H = a + W,
                                        A = new r.TimelineMax;
                                    E = Math.abs(Math.abs(f - u / 2 - .5) - u / 2 - .5) * Math.abs(Math.abs(m - p / 2 - .5) - p / 2 - .5), M.css({
                                        zIndex: E
                                    }), z = V / 2, F = H / 2, D = (_ = "horizontal" == d.animation.direction ? Math.abs(d.animation.transition.rotateY) > 90 && "large" != d.tile.depth ? Math.floor(V / 7) + P : V : Math.abs(d.animation.transition.rotateX) > 90 && "large" != d.tile.depth ? Math.floor(H / 7) + W : H) / 2, this.createCuboids("ls-3d-box", M, 0, 0, 0, 0, -D, 0, 0, z + "px " + F + "px 0px"), this.createCuboids("ls-3d-front", M.find(".ls-3d-box"), V, H, 0, 0, D, 0, 0), "vertical" == d.animation.direction && Math.abs(d.animation.transition.rotateX) > 90 ? this.createCuboids("ls-3d-back", M.find(".ls-3d-box"), V, H, 0, 0, -D, 180, 0) : this.createCuboids("ls-3d-back", M.find(".ls-3d-box"), V, H, 0, 0, -D, 0, 180), this.createCuboids("ls-3d-left", M.find(".ls-3d-box"), _, H, -D, 0, 0, 0, -90), this.createCuboids("ls-3d-right", M.find(".ls-3d-box"), _, H, V - D, 0, 0, 0, 90), this.createCuboids("ls-3d-top", M.find(".ls-3d-box"), V, _, 0, -D, 0, 90, 0), this.createCuboids("ls-3d-bottom", M.find(".ls-3d-box"), V, _, 0, H - D, 0, -90, 0), C = M.find(".ls-3d-front"), k = "horizontal" == d.animation.direction ? Math.abs(d.animation.transition.rotateY) > 90 ? M.find(".ls-3d-back") : d.animation.transition.rotateY > 0 ? M.find(".ls-3d-left") : M.find(".ls-3d-right") : Math.abs(d.animation.transition.rotateX) > 90 ? M.find(".ls-3d-back") : d.animation.transition.rotateX > 0 ? M.find(".ls-3d-bottom") : M.find(".ls-3d-top"), R = c[T] * d.tile.delay, N = o.transitions.slide.$wrapper.find(".ls-3d-container:eq( " + T + " ) .ls-3d-box"), d.before && d.before.transition ? (d.before.transition.delay = d.before.transition.delay ? (d.before.transition.delay + R) / 1e3 : R / 1e3, A.to(N[0], d.before.duration / 1e3, o.functions.convert.transition(d.before.transition, d.before.easing))) : d.animation.transition.delay = d.animation.transition.delay ? (d.animation.transition.delay + R) / 1e3 : R / 1e3, A.to(N[0], d.animation.duration / 1e3, o.functions.convert.transition(d.animation.transition, d.animation.easing)), d.after && (d.after.transition || (d.after.transition = {}), A.to(N[0], d.after.duration / 1e3, o.functions.convert.transition(d.after.transition, d.after.easing, "after"))), o.transitions._slideTransition.add(A, 0)
                                } else {
                                    var X, Y, j, K, q, U, G, Q, Z = "auto",
                                        J = "auto",
                                        ee = "auto",
                                        te = "auto",
                                        ie = 1,
                                        se = 1,
                                        ae = {};
                                    switch (Y = "random" == d.transition.direction ? (X = ["top", "bottom", "right", "left"])[Math.floor(Math.random() * X.length)] : d.transition.direction, -1 != d.name.toLowerCase().indexOf("mirror") && T % 2 == 0 && (h = "prev" == h ? "next" : "prev"), "prev" == h && (Y = {
                                        top: "bottom",
                                        bottom: "top",
                                        left: "right",
                                        right: "left",
                                        topleft: "bottomright",
                                        topright: "bottomleft",
                                        bottomleft: "topright",
                                        bottomright: "topleft"
                                    }[Y]), Y) {
                                        case "top":
                                            Z = ee = -M.data("style").height, J = te = 0;
                                            break;
                                        case "bottom":
                                            Z = ee = M.data("style").height, J = te = 0;
                                            break;
                                        case "left":
                                            Z = ee = 0, J = te = -M.data("style").width;
                                            break;
                                        case "right":
                                            Z = ee = 0, J = te = M.data("style").width;
                                            break;
                                        case "topleft":
                                            Z = M.data("style").height, ee = 0, J = M.data("style").width, te = 0;
                                            break;
                                        case "topright":
                                            Z = M.data("style").height, ee = 0, J = -M.data("style").width, te = 0;
                                            break;
                                        case "bottomleft":
                                            Z = -M.data("style").height, ee = 0, J = M.data("style").width, te = 0;
                                            break;
                                        case "bottomright":
                                            Z = -M.data("style").height, ee = 0, J = -M.data("style").width, te = 0
                                    }
                                    switch (this.scale2D = d.transition.scale ? d.transition.scale : 1, 1 == w && 1 != this.scale2D && (Z /= 2, ee /= 2, J /= 2, te /= 2), d.transition.type) {
                                        case "fade":
                                            Z = ee = J = te = 0, ie = 0, se = 1;
                                            break;
                                        case "mixed":
                                            ie = 0, se = 1, 1 == this.scale2D && (ee = te = 0)
                                    }
                                    if ((d.transition.rotate || d.transition.rotateX || d.transition.rotateY || 1 != this.scale2D) && "slide" != d.transition.type ? M.css({
                                            overflow: "visible"
                                        }) : M.css({
                                            overflow: "hidden"
                                        }), 1 == w ? this.$curTiles.css({
                                            overflow: "visible"
                                        }) : this.$curTiles.css({
                                            overflow: "hidden"
                                        }), !0 === x || "slide" == d.transition.type || !0 === w ? (j = M.appendTo(this.$curTiles), K = M.clone().appendTo(this.$nextTiles), C = e("<div>").addClass("ls-curtile").appendTo(j)) : K = M.appendTo(this.$nextTiles), k = e("<div>").addClass("ls-nexttile").appendTo(K), q = c[T] * d.tile.delay / 1e3, U = d.transition.rotate ? d.transition.rotate : 0, G = d.transition.rotateX ? d.transition.rotateX : 0, Q = d.transition.rotateY ? d.transition.rotateY : 0, "prev" == h && (U = -U, G = -G, Q = -Q), o.transitions._slideTransition.fromTo(k[0], d.transition.duration / 1e3, {
                                            immediateRender: !1,
                                            autoCSS: !1,
                                            css: {
                                                x: -J,
                                                y: -Z,
                                                display: "block",
                                                opacity: ie,
                                                rotation: U,
                                                rotationX: G,
                                                rotationY: Q,
                                                scale: this.scale2D
                                            }
                                        }, {
                                            autoCSS: !1,
                                            css: {
                                                x: 0,
                                                y: 0,
                                                opacity: se,
                                                rotation: 0,
                                                rotationX: 0,
                                                rotationY: 0,
                                                scale: 1
                                            },
                                            ease: o.functions.convert.easing(d.transition.easing)
                                        }, q), 1 == x && (void 0 === o.transitions.nextSlide.data.$background || void 0 !== o.transitions.nextSlide.data.$background && (-1 != o.transitions.nextSlide.data.$background.attr("src").toLowerCase().indexOf("png") || o.transitions.nextSlide.data.$background.width() < o.slider.width || o.transitions.nextSlide.data.$background.height() < o.slider.height)) && (ae.opacity = 0), ("slide" == d.transition.type || 1 == w) && -1 == d.name.toLowerCase().indexOf("mirror")) {
                                        var oe = 0;
                                        0 !== U && (oe = -U), ae.x = te, ae.y = ee, ae.rotation = oe, ae.scale = this.scale2D, ae.opacity = ie
                                    }
                                    void 0 !== C && o.transitions._slideTransition.to(C[0], d.transition.duration / 1e3, {
                                        autoCSS: !1,
                                        css: ae,
                                        ease: o.functions.convert.easing(d.transition.easing)
                                    }, q)
                                }
                                I = T % u * s, O = Math.floor(T / u) * a, void 0 !== o.transitions.curSlide.data.$background && (L = o.transitions.curSlide.data.$background.data(o.defaults.init.dataKey), "3d" === t || "2d" === t && (!0 === x || "slide" === d.transition.type || !0 === w) ? C.append(e("<img>").attr("src", g).css({
                                    width: L.responsive.width,
                                    height: L.responsive.height,
                                    "-webkit-filter": L.responsive.filter,
                                    filter: L.responsive.filter,
                                    "-ms-transform": "translateX(" + (L.responsive.x - I) + "px) translateY(" + (L.responsive.y - O) + "px)" + L.responsive.kbRotation + L.responsive.kbScale,
                                    "-webkit-transform": "translateX(" + (L.responsive.x - I) + "px) translateY(" + (L.responsive.y - O) + "px)" + L.responsive.kbRotation + L.responsive.kbScale,
                                    transform: "translateX(" + (L.responsive.x - I) + "px) translateY(" + (L.responsive.y - O) + "px)" + L.responsive.kbRotation + L.responsive.kbScale
                                })) : 0 === this.$curTiles.children().length && this.$curTiles.css("background-color", o.transitions.curSlide.data.backgroundColor).append(e("<img>").attr("src", g).css({
                                    width: L.responsive.width,
                                    height: L.responsive.height,
                                    "-webkit-filter": L.responsive.filter,
                                    filter: L.responsive.filter,
                                    "-ms-transform": "translateX(" + L.responsive.x + "px) translateY(" + L.responsive.y + "px)" + L.responsive.kbRotation + L.responsive.kbScale,
                                    "-webkit-transform": "translateX(" + L.responsive.x + "px) translateY(" + L.responsive.y + "px)" + L.responsive.kbRotation + L.responsive.kbScale,
                                    transform: "translateX(" + L.responsive.x + "px) translateY(" + L.responsive.y + "px)" + L.responsive.kbRotation + L.responsive.kbScale
                                }))), "transparent" === o.transitions.curSlide.data.backgroundColor || o.transitions.curSlide.data.$backgroundVideo.length || ("3d" === t || "2d" === t && (!0 === x || "slide" === d.transition.type || !0 === w) ? C.css("background-color", o.transitions.curSlide.data.backgroundColor) : 0 === this.$curTiles.children().length && this.$curTiles.css("background-color", o.transitions.curSlide.data.backgroundColor)), void 0 !== o.transitions.nextSlide.data.$background && (B = ($ = o.transitions.nextSlide.data.$background.data(o.defaults.init.dataKey)).kenBurns[y], k.append(e("<img>").attr("src", v).css({
                                    width: $.responsive.width,
                                    height: $.responsive.height,
                                    "-webkit-filter": o.transitions.nextSlide.filter.from || "none",
                                    filter: o.transitions.nextSlide.filter.from || "none",
                                    "-ms-transform": "translateX(" + ($.responsive.x - I) + "px) translateY(" + ($.responsive.y - O) + "px) rotate(" + B.rotation + "deg) scale(" + B.scale + ")",
                                    "-webkit-transform": "translateX(" + ($.responsive.x - I) + "px) translateY(" + ($.responsive.y - O) + "px) rotate(" + B.rotation + "deg) scale(" + B.scale + ")",
                                    transform: "translateX(" + ($.responsive.x - I) + "px) translateY(" + ($.responsive.y - O) + "px) rotate(" + B.rotation + "deg) scale(" + B.scale + ")"
                                }))), "transparent" === o.transitions.nextSlide.data.backgroundColor || o.transitions.nextSlide.data.$backgroundVideo.length || k.css("background-color", o.transitions.nextSlide.data.backgroundColor)
                            }
                            o.transitions.slide.$wrapper.prependTo(o.o.preferBlendMode ? o.slider.$layersWrapper : o.slider.$innerWrapper), o.transitions.slide.start()
                        },
                        createCuboids: function(t, i, s, a, o, r, n, l, d, u) {
                            var p = "translate3d( " + o + "px, " + r + "px, " + n + "px)";
                            0 !== l && (p += "rotateX( " + l + "deg)"), 0 !== d && (p += "rotateY( " + d + "deg)");
                            var c = {
                                width: s,
                                height: a,
                                transform: p,
                                "-ms-transform": p,
                                "-webkit-transform": p
                            };
                            u && (c["transform-origin"] = u, c["-ms-transform-origin"] = u, c["-webkit-transform-origin"] = u), e("<div>").addClass(t).css(c).appendTo(i)
                        }
                    }
                },
                layers: { in : {
                        onStart: function(e) {
                            e.data(o.defaults.init.dataKey).hover.enabled && o.transitions.layers.hover.enable(e)
                        },
                        onComplete: function(e) {
                            o.media.playIfAllowed(e)
                        }
                    }, out: {
                        forced: function() {
                            if (o.transitions._forceLayersOut) {
                                if (o.transitions._slideTimeline) {
                                    var t, i, s = new r.TimelineMax({
                                            paused: !0,
                                            autoRemoveChildren: !0
                                        }),
                                        a = [],
                                        n = o.layers.get("current, in, static, active").add(o.layers.get("current, out, static, active")),
                                        l = o.layers.get("current, out, notstatic, active"),
                                        d = o.layers.get("current, out, active"),
                                        u = function(e) {
                                            s.add(e, 100 - e.duration() * e.progress())
                                        };
                                    e().add(n).add(l).each(function() {
                                        var s = e(this).data(o.defaults.init.dataKey);
                                        if (s.loop._timeline && (o.transitions._slideTimeline.remove(s.loop._timeline), s.loop._timeline.play()), s.is.static) {
                                            t = [s.elements.$wrapper[0]], s.elements.$clipWrapper && (t = t.concat(s.elements.$clipWrapper[0])), s.textIn.nodes && (t = t.concat(s.textIn.nodes));
                                            for (var r = 0; r < t.length; r++) a = a.concat(o.transitions._slideTimeline.getTweensOf(t[r], !0));
                                            for (var n = 0; n < a.length; n++) a[n].duration && 0 !== a[n].duration() && (i = a[n], u(i))
                                        }
                                    }), d.each(function() {
                                        e(this).data(o.defaults.init.dataKey).should.reset = !0
                                    }), s.play().seek(100), o.transitions._slideTimeline.stop().clear()
                                }
                                o.transitions._forceLayersOut.play()
                            }
                            o.slider.$layersWrapper.find(".ls-link").css({
                                display: "none"
                            })
                        },
                        onStart: function(e) {},
                        onComplete: function(e) {
                            var t = e.data(o.defaults.init.dataKey);
                            (o.slider.state.changingSlides || t.settings.slideOut !== o.slides.current.index) && o.transitions.layers.reset(e, t), t.hover.enabled && o.transitions.layers.hover.disable(e)
                        }
                    }, reset: function(e, t) {
                        t.loop._timeline && (t.loop._timeline.stop().clear(), delete t.loop._timeline, r.TweenMax.set(t.elements.$loopWrapper[0], t.reset.loopWrapperOnSlideChange)), r.TweenMax.set(t.elements.$wrapper[0], t.reset.wrapperOnSlideChange), r.TweenMax.set(e[0], {
                            "-webkit-filter": "none",
                            filter: "none"
                        }), t.should.update && (t.textInNodesFrom.random = {}, t.textOutNodesTo.random = {}, o.layers.update.data(e)), t.should.reset = !1
                    }, timeline: {
                        shouldRestart: !1,
                        create: function(t) {
                            var s, n, l, d, u = t ? "current" : "next";
                            o.transitions.curNext = u, o.transitions.layers.timeline.shouldRestart = !1, o.transitions.layers.timeline.resetStates(), o.transitions._slideTimeline && (o.transitions._slideTimeline.pause().progress(0).kill().clear(!0), o.transitions._slideTimeline = null), o.transitions._slideTimeline = new r.TimelineMax({
                                paused: !0,
                                onStart: function() {
                                    o.api.hasEvent("slideTimelineDidStart") && i.triggerHandler("slideTimelineDidStart", o.api.eventData())
                                },
                                onComplete: function() {
                                    o.o.playByScroll && o.o.playByScrollSkipSlideBreaks && ("next" === o.slideshow.direction ? o.transitions.layers.timeline.scrollForward(!0) : o.transitions.layers.timeline.scrollBackwards(!0, !0))
                                },
                                onReverseComplete: function() {
                                    o.api.hasEvent("slideTimelineDidReverseComplete") && i.triggerHandler("slideTimelineDidReverseComplete", o.api.eventData()), o.transitions.layers.timeline.shouldReplay && (o.transitions.layers.timeline.shouldRestart = !1, o.transitions._slideTimeline.play()), o.o.playByScroll && o.o.playByScrollSkipSlideBreaks && o.transitions.layers.timeline.scrollBackwards(!0, !1)
                                },
                                onUpdate: function(e) {
                                    o.api.hasEvent("slideTimelineDidUpdate") && i.triggerHandler("slideTimelineDidUpdate", e)
                                },
                                onUpdateParams: ["{self}"]
                            }), this.totalDuration = 0, this.progress = 1, o.transitions._forceLayersOut = new r.TimelineMax({
                                paused: !0,
                                autoRemoveChildren: !0
                            }), s = o.layers.get(u + ", in, notactive"), n = o.layers.get(u + ", out, notstatic").add(o.layers.get(u + ", out, active, static")), l = o.layers.get(u + ", in, bgonly, notactive"), d = e().add(s).add(n).add(l), this.addLayers(s, "in", o.transitions._slideTimeline, o.transitions._forceLayersOut), this.addLayers(n, "out", o.transitions._slideTimeline, o.transitions._forceLayersOut), -1 !== o.slides[u].data.duration && o.slides[u].data.duration < this.totalDuration ? (this.progress = o.slides[u].data.duration / this.totalDuration, o.debugMode && o.debug.add("warn", "slideTimeline.duration", [o.slides[u].data.duration, this.totalDuration])) : o.transitions._slideTimeline.duration() > this.totalDuration && (this.progress = this.totalDuration / o.transitions._slideTimeline.duration()), -1 === o.slides[u].data.duration ? (o.slides[u].data.duration = this.totalDuration, o.slides[o.slides[u].index].data.duration = this.totalDuration) : this.totalDuration = o.slides[u].data.duration, this.addLayers(l, "in", o.transitions._slideTimeline, o.transitions._forceLayersOut), !0 === o.transitions.layers.timeline.shouldRestart && o.debugMode && o.debug.add("warn", "slideTimeline.restart", o.o.allowRestartOnResize ? "enabled" : "disabled");
                            for (var p = 0; p < d.length; p++) e(d[p]).data(o.defaults.init.dataKey).parallax.enabled && e(d[p]).data(o.defaults.init.dataKey).elements.$parallaxWrapper.attr("data-ls-parallax", "active");
                            if (o.transitions.layers.parallax.trigger(), o.api.hasEvent("slideTimelineDidCreate") && i.triggerHandler("slideTimelineDidCreate", {
                                    slideTimeline: o.transitions._slideTimeline,
                                    layersOnSlideTimeline: d,
                                    slideTimelineDuration: this.totalDuration
                                }), o.transitions.timers.create(), o.transitions.timers.bar._transition && o.transitions._slideTimeline.add(o.transitions.timers.bar._transition.play(), 0), o.transitions.timers.circle._transition && o.transitions._slideTimeline.add(o.transitions.timers.circle._transition.play(), 0), o.transitions.timers.slidebar._transition && o.transitions._slideTimeline.add(o.transitions.timers.slidebar._transition.play(), 0), o.transitions._slideTimeline.call(function() {
                                    if (!o.transitions._slideTimeline.reversed()) {
                                        if (o.api.hasEvent("slideTimelineDidComplete") && !1 === i.triggerHandler("slideTimelineDidComplete", o.api.eventData())) return;
                                        o.functions.setStates(o.transitions.layers.timeline, {
                                            finished: !0
                                        }), !o.slideshow.isPaused() && o.slideshow.state.running ? o.slideshow.changeTo(o.slides.next.index) : o.slideshow.state.pausedByLastCycle && o.transitions.timers.reverse()
                                    }
                                }, [], this, o.slides[u].data.duration), o.slides.next.data.$link && o.slides.next.data.$link.css({
                                    display: "block"
                                }), (!o.o.startInViewport || "inside" !== o.slider.positionToViewport && !o.o.playByScrollStart) && o.o.startInViewport || !(o.slider.isPopup && o.slider.state.popupIsVisible && o.slider.state.popupShouldStart) && o.slider.isPopup || (o.o.pauseLayers && o.slideshow.isPaused() && o.transitions._slideTimeline.timeScale(0), o.transitions.layers.timeline.play(), o.o.playByScroll && "up" === o.device.scroll.directionAtSlideTransitionStart && o.transitions._slideTimeline.progress(1)), i.trigger("mouseleave.globalhover" + a), i.off("mouseenter.globalhover" + a + " mouseleave.globalhover" + a + " mousemove.globalhover" + a), o.slides[u].data.globalhover) {
                                var c = o.layers.get(u + ",in,notactive").add(o.layers.get("static,active"));
                                i.on("mouseenter.globalhover" + a, function() {
                                    c.each(function() {
                                        o.transitions.layers.hover.mouseEnter(e(this), e(this).data(o.defaults.init.dataKey))
                                    })
                                }), i.on("mouseleave.globalhover" + a, function() {
                                    c.each(function() {
                                        o.transitions.layers.hover.mouseLeave(e(this), e(this).data(o.defaults.init.dataKey))
                                    })
                                }), i.on("mousemove.globalhover" + a, function() {
                                    c.each(function() {
                                        o.transitions.layers.hover.mouseMove(e(this), e(this).data(o.defaults.init.dataKey))
                                    })
                                })
                            }
                        },
                        prepare: function() {
                            o.slides.next.data.overflow && "hidden" !== o.slides.next.data.overflow ? (o.slider.$layersWrapper.addClass("ls-visible"), o.slider.$slideBGWrapper.addClass("ls-visible")) : (o.slider.$layersWrapper.removeClass("ls-visible"), o.slider.$slideBGWrapper.removeClass("ls-visible")), this.create()
                        },
                        getTiming: function(t, i, s, a) {
                            if ("number" == typeof i) return i;
                            i = i.toLowerCase();
                            var r, n, l, d, u, p = o.defaults.layer.timelineHierarchy,
                                c = 0;
                            if (-1 !== i.indexOf("*") && (u = "*"), -1 !== i.indexOf("/") && (u = "/"), -1 !== i.indexOf("+") && (u = "+"), -1 !== i.indexOf("-") && (u = "-"), u)
                                if (d = i.split(u), r = e.trim(d[0]), l = parseInt(e.trim(d[1])), p[r] && -1 !== p[s][1].indexOf(p[r][0]))
                                    if (n = "number" == typeof t.timeline[r] ? t.timeline[r] : t.timeline[r](t), a) c = l / 1e3;
                                    else switch (u) {
                                        case "*":
                                            c = n * l;
                                            break;
                                        case "/":
                                            c = n / l;
                                            break;
                                        case "+":
                                            c = n + l / 1e3;
                                            break;
                                        case "-":
                                            c = n - l / 1e3
                                    } else o.debugMode && (p[r] || o.debug.add("warn", "layerTransition.timing1", r), -1 === p[s][1].indexOf(p[r][0]) && o.debug.add("warn", "layerTransition.timing3", [r, p[r], s, p[s]])), ("+" === u || a) && (c = l / 1e3);
                            else p[r = e.trim(i)] && -1 !== p[s][1].indexOf(p[r][0]) ? c = a ? 0 : "number" == typeof t.timeline[r] ? t.timeline[r] : t.timeline[r](t) : o.debugMode && (p[r] ? -1 === p[s][1].indexOf(p[r][0]) && o.debug.add("warn", "layerTransition.timing3", [r, p[r], s, p[s]]) : o.debug.add("warn", "layerTransition.timing1", r));
                            return (c !== c || c < 0) && (o.debugMode && o.debug.add("warn", "layerTransition.timing2", [s, r, c]), c = 0), c
                        },
                        addLayers: function(t, i, s, a) {
                            for (var n = 0, l = t.length; n < l; n++) {
                                var d, u = e(t[n]),
                                    p = u.data(o.defaults.init.dataKey),
                                    c = p.elements.$wrapper,
                                    h = p.elements.$clipWrapper,
                                    m = p.elements.$loopWrapper;
                                if (p.should.reset && o.transitions.layers.reset(u, p), u.hasClass("ls-bg")) p.kenBurns.zoom && s.fromTo(u.closest(".ls-bg-wrap"), o.transitions.nextSlide.data.duration + o.transitions.nextSlide.data.calculatedTimeShift, {
                                    autoCSS: !1,
                                    css: p.kenBurns.from
                                }, {
                                    autoCSS: !1,
                                    css: p.kenBurns.to,
                                    ease: r.Quad.easeInOut
                                }, -o.transitions.nextSlide.data.calculatedTimeShift), e.isEmptyObject(p.filter.values.bgFrom) && e.isEmptyObject(p.filter.values.bgTo) || (p.filter.transitions.bg || (p.filter.transitions.bg = o.transitions.layers.filters.createTransition(p, "bg", p.filter.values.bgFrom, p.filter.values.bgTo)), s.to([{
                                    p: 0
                                }, u[0]], o.transitions.nextSlide.data.duration, {
                                    p: 1,
                                    autoCSS: !1,
                                    ease: r.Sine.easeInOut,
                                    onUpdate: o.transitions.layers.filters.animate,
                                    onUpdateParams: ["{self}", p.filter.transitions.bg]
                                }, 0));
                                else switch (i) {
                                    case "in":
                                        if (p.in.enabled && (p.settings.timelineIsCalculated || ("number" != typeof p.in.startAt && (p.in.startAt = 0), p.timeline.transitioninstart = p.in.startAt, p.timeline.transitioninend = p.timeline.transitioninstart + p.in.duration), o.resize.transformProperties(u, p.inLayerFromCSS, p.inLayerShouldBeConverted), o.resize.styleProperties(p.inLayerStyleFromCSS, p.inLayerStyleShouldBeConvertedFrom), o.resize.styleProperties(p.inLayerStyleToCSS, p.inLayerStyleShouldBeConvertedTo), p.inLayerFromCSS.transformPerspective = p.transformPerspective.layer * o.resize.ratio, p.clip.enabled && (p.original.clip || (p.original.clip = p.clip.min, p.original.clipShouldBeConverted = !0), p.inClipShouldBeConverted.clip ? (p.inClipFromCSS.clip = o.resize.clip(u, p.inClipShouldBeConverted.clip, !0), p.inClipToCSS.clip = o.resize.clip(u, p.original.clip, p.original.clipShouldBeConverted), s.fromTo(h[0], p.in.duration, p.inClipFrom, p.inClipTo, p.timeline.transitioninstart)) : r.TweenMax.set(h[0], {
                                                clip: o.resize.clip(u, p.original.clip, p.original.clipShouldBeConverted)
                                            }), o.transitions.layers.timeline.shouldRestart = !0), e.isEmptyObject(p.filter.values.in) ? e.isEmptyObject(p.filter.values.out) || u.css("filter", p.original.filter) : (p.filter.transitions.in || (p.filter.transitions.in = o.transitions.layers.filters.createTransition(p, "in", p.filter.values.in, p.filter.values.style)), s.to([{
                                                p: 0
                                            }, u[0]], p.in.duration, {
                                                p: 1,
                                                autoCSS: !1,
                                                ease: p.inLayerTo.ease,
                                                onUpdate: o.transitions.layers.filters.animate,
                                                onUpdateParams: ["{self}", p.filter.transitions.in]
                                            }, p.timeline.transitioninstart)), s.fromTo(c[0], p.in.duration, p.inLayerFrom, p.inLayerTo, p.timeline.transitioninstart), s.fromTo(u[0], p.in.duration, p.inLayerStyleFrom, p.inLayerStyleTo, p.timeline.transitioninstart)), p.is.textLayer && ((p.textIn.type || p.textOut.type) && o.transitions.layers.splitType.resetNodes(u, p), p.textIn.enabled && (p.in.enabled || s.to(c[0], 0, e.extend(!0, {}, p.inLayerTo, p.init.wrapper), p.timeline.textinstart), p.textIn.nodes = o.transitions.layers.splitType.setNodesSequence(p.textIn.type.split("_"), p.textIn.ns), o.resize.transformProperties(u, p.textInNodesFrom, p.textInShouldBeConverted), p.textInNodesFrom.transformPerspective = p.transformPerspective.text * o.resize.ratio, e.isEmptyObject(p.textInShouldBeConverted.random) || o.transitions.layers.splitType.setRandomProperties(p, p.textInShouldBeConverted.random, p.textInNodesFrom), e.isEmptyObject(p.textInNodesFrom.random) || o.transitions.layers.splitType.setRandomProperties(p, p.textInNodesFrom.random, p.textInNodesFrom), delete p.textInNodesFrom.random, p.settings.timelineIsCalculated || (p.timeline.textinstart = this.getTiming(p, p.textIn.startAt, "textinstart"), p.timeline.textinend = p.timeline.textinstart + (p.textIn.nodes.length - 1) * p.textIn.shiftNodes + p.textIn.duration), s.staggerFromTo(p.textIn.nodes, p.textIn.duration, p.textInNodesFrom, p.textInNodesTo, p.textIn.shiftNodes, p.timeline.textinstart, function(e) {
                                                o.transitions.layers.in.onComplete(e)
                                            }, [u]))), p.is.keyframe && o.o.playByScroll && s.addPause(p.timeline.allinend(), function() {
                                                setTimeout(function() {
                                                    delete o.timeouts.scroll, o.transitions.layers.timeline.timeScaleModifier = 0, o.device.scroll.timeout = 250
                                                }, 500)
                                            }), p.loop.enabled) {
                                            var f = new r.TimelineMax({
                                                repeat: p.loop.repeat,
                                                repeatDelay: p.loop.repeatDelay,
                                                yoyo: p.loop.yoyo,
                                                paused: !0
                                            });
                                            p.settings.timelineIsCalculated && !p.is.static || (p.timeline.loopstart = this.getTiming(p, p.loop.startAt, "loopstart"), p.timeline.loopend = -1 !== p.loop.count && p.timeline.loopstart + (p.loop.repeat + 1) * p.loop.duration + p.loop.repeat * p.loop.repeatDelay), p.loop._timeline = f, o.resize.transformProperties(u, p.loopToCSS, {
                                                x: p.loopLayerShouldBeConverted.x,
                                                y: p.loopLayerShouldBeConverted.y
                                            }), (p.loopToCSS.x && 0 !== p.loopToCSS.x || p.loopToCSS.y && 0 !== p.loopToCSS.y) && (o.transitions.layers.timeline.shouldRestart = !0), p.loopFromCSS.transformOrigin = o.functions.convert.transformOrigin(p.loopLayerShouldBeConverted.transformOrigin, u), p.loopFromCSS.transformPerspective = p.transformPerspective.loop * o.resize.ratio, e.isEmptyObject(p.filter.values.loop) || (p.filter.transitions.loop || (p.filter.transitions.loop = o.transitions.layers.filters.createTransition(p, "loop", e.isEmptyObject(p.filter.values.afterIn) ? p.filter.values.style : p.filter.values.afterIn, p.filter.values.loop)), f.to([{
                                                p: 0
                                            }, u[0]], p.loop.duration, {
                                                p: 1,
                                                autoCSS: !1,
                                                ease: p.loopTo.ease,
                                                onUpdate: o.transitions.layers.filters.animate,
                                                onUpdateParams: ["{self}", p.filter.transitions.loop]
                                            }, 0)), f.fromTo(m[0], p.loop.duration, p.loopFrom, p.loopTo, 0), p.loopClipShouldBeConverted.clip && (p.loopClipToCSS.clip = o.resize.clip(u, p.loopClipShouldBeConverted.clip, !0), f.to(h[0], p.loop.duration, p.loopClipTo, 0), o.transitions.layers.timeline.shouldRestart = !0), -1 !== p.loop.repeat && ("looplayers" === o.o.pauseOnHover || o.gui.timers.slidebar.$element || o.o.playByScroll) ? (s.add(f, p.timeline.loopstart), f.play()) : s.addCallback(function(e) {
                                                e.play()
                                            }, p.timeline.loopstart, [f])
                                        }
                                        p.is.static && (p.timeline.staticfrom = p.timeline.transitioninend, p.timeline.staticto = "100%", p.settings.timelineIsCalculated || (d = Math.max(p.timeline.allinandloopend(), 0), this.totalDuration = Math.max(this.totalDuration, d)));
                                        break;
                                    case "out":
                                        p.is.textLayer && p.textOut.enabled && (p.textOut.nodes = o.transitions.layers.splitType.setNodesSequence(p.textOut.type.split("_"), p.textOut.ns), o.resize.transformProperties(u, p.textOutNodesTo, p.textOutShouldBeConverted, p.textOutNodesFrom), p.textOutNodesFrom.transformPerspective = p.transformPerspective.text * o.resize.ratio, e.isEmptyObject(p.textOutShouldBeConverted.random) || o.transitions.layers.splitType.setRandomProperties(p, p.textOutShouldBeConverted.random, p.textOutNodesTo), e.isEmptyObject(p.textOutNodesTo.random) || o.transitions.layers.splitType.setRandomProperties(p, p.textOutNodesTo.random, p.textOutNodesTo), delete p.textOutNodesTo.random, p.settings.timelineIsCalculated || (p.timeline.textoutstart = this.getTiming(p, p.textOut.startAt, "textoutstart"), p.timeline.textoutend = p.timeline.textoutstart + (p.textOut.nodes.length - 1) * p.textOut.shiftNodes + p.textOut.duration), p.clip.enabled && (void 0 === p.outClipShouldBeConverted.clip && s.to(h[0], 0, {
                                            immediateRender: !1,
                                            css: {
                                                clip: o.resize.clip(u, p.clip.max)
                                            }
                                        }, p.timeline.textoutstart), o.transitions.layers.timeline.shouldRestart = !0), s.staggerFromTo(p.textOut.nodes, p.textOut.duration, p.textOutNodesFrom, p.textOutNodesTo, p.textOut.shiftNodes, p.timeline.textoutstart)), o.resize.transformProperties(u, p.outLayerToCSS, p.outLayerShouldBeConverted, p.outLayerFromCSS), o.resize.styleProperties(p.outLayerStyleFromCSS, p.outLayerStyleShouldBeConvertedFrom), o.resize.styleProperties(p.outLayerStyleToCSS, p.outLayerStyleShouldBeConvertedTo), p.outLayerFromCSS.transformPerspective = p.transformPerspective.layer * o.resize.ratio, "slidechangeonly" !== p.out.startAt ? (p.settings.timelineIsCalculated && !p.is.static || (p.is.static ? (p.timeline.staticfrom = 0, p.timeline.transitionoutstart = this.getTiming(p, p.out.startAt, "transitionoutstart", !0), p.timeline.staticto = p.timeline.transitionoutstart) : p.timeline.transitionoutstart = Math.max(this.getTiming(p, p.out.startAt, "transitionoutstart"), p.timeline.transitioninend), p.timeline.transitionoutend = p.timeline.transitionoutstart + p.out.duration), p.clip.enabled && (void 0 === p.outClipShouldBeConverted.clip ? s.to(h[0], 0, {
                                            immediateRender: !1,
                                            css: {
                                                clip: o.resize.clip(u, p.clip.max)
                                            }
                                        }, p.timeline.transitionoutstart) : (p.outClipToCSS.clip = o.resize.clip(u, p.outClipShouldBeConverted.clip, !0), s.to(h[0], p.out.duration, p.outClipTo, p.timeline.transitionoutstart)), o.transitions.layers.timeline.shouldRestart = !0), e.isEmptyObject(p.filter.values.out) || (p.filter.transitions.out || (p.filter.transitions.out = o.transitions.layers.filters.createTransition(p, "out", e.isEmptyObject(p.filter.values.afterLoop) ? e.isEmptyObject(p.filter.values.afterIn) ? p.filter.values.style : p.filter.values.afterIn : p.filter.values.afterLoop, p.filter.values.out)), s.to([{
                                            p: 0
                                        }, u[0]], p.out.duration, {
                                            p: 1,
                                            autoCSS: !1,
                                            ease: p.outLayerTo.ease,
                                            onUpdate: o.transitions.layers.filters.animate,
                                            onUpdateParams: ["{self}", p.filter.transitions.out]
                                        }, p.timeline.transitionoutstart)), s.fromTo(c[0], p.out.duration, p.outLayerFrom, p.outLayerTo, p.timeline.transitionoutstart), s.fromTo(u[0], p.out.duration, p.outLayerStyleFrom, p.outLayerStyleTo, p.timeline.transitionoutstart), s.fromTo(c[0], 0, p.init.wrapper, p.reset.wrapperOnTimelineEnd, p.timeline.transitionoutend)) : (p.timeline.staticfrom = 0, p.timeline.staticto = "100%"), (!p.is.static || p.is.static && p.settings.slideOut === o.slides.next.index) && (a.fromTo(c[0], o.o.forceLayersOutDuration, p.outLayerFrom, p.outLayerTo, 0), a.fromTo(u[0], o.o.forceLayersOutDuration, p.outLayerStyleFrom, p.outLayerStyleTo, 0), p.clip.enabled && void 0 !== p.outClipShouldBeConverted.clip && (p.outClipToCSS.clip = o.resize.clip(u, p.outClipShouldBeConverted.clip, !0), a.to(h[0], o.o.forceLayersOutDuration, p.outClipTo, 0))), d = Math.max(p.timeline.alloutandloopend(), 0), this.totalDuration = Math.max(this.totalDuration, d), p.settings.timelineIsCalculated = !0
                                }
                            }
                        },
                        play: function() {
                            o.transitions._slideTimeline && (o.transitions._slideTimeline.play(), o.functions.setStates(this, {
                                started: !0,
                                running: !0,
                                stopped: !1,
                                paused: !1
                            }))
                        },
                        pause: function(t) {
                            var t = e.isNumeric(t) ? t : .75;
                            o.transitions._slideTimeline && (r.TweenMax.to(o.transitions._slideTimeline, t, {
                                timeScale: 0
                            }), o.functions.setStates(this, {
                                paused: !0,
                                stopped: !1
                            }))
                        },
                        resume: function() {
                            o.transitions._slideTimeline && (r.TweenMax.to(o.transitions._slideTimeline, .75, {
                                timeScale: 1
                            }), o.functions.setStates(this, {
                                paused: !1,
                                stopped: !1
                            }))
                        },
                        reverse: function() {
                            o.transitions._slideTimeline && o.transitions._slideTimeline.reverse()
                        },
                        scrollForward: function(e) {
                            if (e || (this.play(), this.modifyTimeScale()), o.transitions._slideTimeline && !o.slider.isBusy() && (0 === o.transitions._slideTimeline.totalDuration() || 1 === o.transitions._slideTimeline.progress()) && "down" === o.device.scroll.direction) {
                                o.slideshow.direction = "next";
                                var t = o.slideshow.sequence.normalized;
                                t.indexOf(o.slides.current.index) === t.length - 1 ? (o.slider.positionToViewport = "under", o.device.scroll.enable(), o.slideshow.direction = "prev") : o.navigation.next()
                            }
                        },
                        scrollBackwards: function(e, t) {
                            e && !t || (this.reverse(), this.modifyTimeScale()), o.transitions._slideTimeline && (o.slider.isBusy() || 0 !== o.transitions._slideTimeline.totalDuration() && 0 !== o.transitions._slideTimeline.progress() || "up" !== o.device.scroll.direction || (o.slideshow.direction = "prev", 0 === o.slideshow.sequence.normalized.indexOf(o.slides.current.index) ? (o.slider.positionToViewport = "over", o.device.scroll.enable(), o.slideshow.direction = "next") : o.navigation.prev()))
                        },
                        modifyTimeScale: function() {
                            if (o.transitions._slideTimeline) {
                                var e = this;
                                r.TweenMax.to(o.transitions._slideTimeline, .25, {
                                    timeScale: 1 + e.timeScaleModifier
                                })
                            }
                        },
                        resetStates: function() {
                            this.state = {
                                started: !1,
                                running: !1,
                                paused: !1,
                                stopped: !1,
                                finished: !1
                            }
                        }
                    }, hover: {
                        enable: function(e) {
                            e.attr("data-ls-canhover", "1")
                        },
                        disable: function(e) {
                            e.attr("data-ls-canhover", "0")
                        },
                        set: function(e, t) {
                            t.elements.$wrapper.on("mouseenter." + a, function() {
                                o.transitions.layers.hover.mouseEnter(e, t)
                            }), t.elements.$wrapper.on("mouseleave." + a, function() {
                                o.transitions.layers.hover.mouseLeave(e, t)
                            }), t.elements.$wrapper.on("mousemove." + a, function() {
                                o.transitions.layers.hover.mouseMove(e, t)
                            })
                        },
                        createTimeline: function(t, i) {
                            if (i.hover._timeline = new r.TimelineMax({
                                    paused: !0,
                                    onReverseComplete: function(e, t) {
                                        t.hover._timeline._reversed && (t.hover._timeline.stop().clear(), delete t.hover._timeline)
                                    },
                                    onReverseCompleteParams: [t, i]
                                }), o.resize.transformProperties(t, i.hoverToCSS, i.hoverShouldBeConverted, i.hoverFromCSS), o.resize.styleProperties(i.hoverToCSS, i.hoverShouldBeConverted), i.hoverFromCSS.transformPerspective = i.transformPerspective.hover * o.resize.ratio, i.hover._tween = r.TweenMax.fromTo(t[0], i.hover.durationIn, i.hoverFrom, i.hoverTo), i.hover._timeline.add(i.hover._tween, 0), t.next().is(".ls-layer-link")) {
                                var s = t.next(),
                                    a = e.extend(!0, {}, i.hoverFrom, {
                                        css: {
                                            opacity: 1,
                                            color: "transparent",
                                            background: "transparent",
                                            z: 0
                                        }
                                    }),
                                    n = e.extend(!0, {}, i.hoverTo, {
                                        css: {
                                            opacity: 1,
                                            color: "transparent",
                                            background: "transparent",
                                            z: 0
                                        }
                                    });
                                i.hover._linkTween = r.TweenMax.fromTo(s[0], i.hover.durationIn, a, n), i.hover._timeline.add(i.hover._linkTween, 0)
                            } else i.hover._linkTween = null;
                            if (i.hover.alwaysOnTop) {
                                var l = {
                                    zIndex: 9999
                                };
                                o.browser.isSafari && (l.transform = "translateZ(999999px)"), i.hover._timeline.to(i.elements.$outerWrapper[0], i.hover.durationIn, {
                                    autoCSS: !1,
                                    css: l
                                }, 0)
                            }
                            i.hover.reverseTimeScale = i.hover.durationIn / i.hover.durationOut == 1 ? 1 : i.hover.durationIn / i.hover.durationOut, this.hoverIn(t, i)
                        },
                        mouseEnter: function(e, t) {
                            "1" === e.attr("data-ls-canhover") && (e.attr("data-ls-hovered", 1), t.elements.$wrapper.off("mousemove." + a), t.hover._timeline ? (t.hover._timeline.play().stop().progress(0), this.hoverIn(e, t)) : this.createTimeline(e, t))
                        },
                        mouseLeave: function(e, t) {
                            t.hover._timeline && (t.hover._timeline.stop().progress(1), this.hoverOut(e, t)), e.removeAttr("data-ls-hovered")
                        },
                        mouseMove: function(e, t) {
                            e.attr("data-ls-hovered") || this.mouseEnter(e, t)
                        },
                        hoverIn: function(e, t) {
                            t.hover._tween.updateTo({
                                ease: t.hover.easeIn
                            }), t.hover._linkTween && t.hover._linkTween.updateTo({
                                ease: t.hover.easeIn
                            }), t.hover._timeline.play().timeScale(1)
                        },
                        hoverOut: function(e, t) {
                            t.hover._tween.updateTo({
                                ease: t.hover.easeOut
                            }), t.hover._linkTween && t.hover._linkTween.updateTo({
                                ease: t.hover.easeOut
                            }), t.hover._timeline.reverse().timeScale(t.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: e(),
                                $3d: e()
                            },
                            scroll: {
                                $2d: e(),
                                $3d: e()
                            }
                        },
                        init: function() {
                            var t = this;
                            i.on("mouseenter." + a, function() {
                                (t.wrappers.cursor.$2d.length || t.wrappers.cursor.$3d.length) && t.calculateTransformProperties()
                            }), i.on("mousemove." + a, function(e) {
                                (t.wrappers.cursor.$2d.length || t.wrappers.cursor.$3d.length) && t.mouseMove(e)
                            }), i.on("mouseleave." + a, function() {
                                (t.wrappers.cursor.$2d.length || t.wrappers.cursor.$3d.length) && t.reset()
                            }), o.device.isMobile && o.device.supportOrientation && (e(window).on("deviceorientation." + a, function() {
                                t.state.ready && t.deviceTurn(event)
                            }), e(window).on("orientationchange." + a, function() {
                                t.calculateTransformProperties()
                            })), e(window).on("scroll.parallax" + a + " touchmove.parallax" + a, function() {
                                (t.wrappers.scroll.$2d.length || t.wrappers.scroll.$3d.length) && t.scroll()
                            }), t.defaults.scrollModifier *= o.o.parallaxScrollReverse ? -1 : 1
                        },
                        addLayer: function(t, i, s, a) {
                            switch (this.state.enabled || (o.functions.setStates(this, {
                                enabled: !0
                            }), this.init()), e.extend(!0, i, this.defaultProperties, o.slides[a].parallax, s.parallax), s.transformPerspective.parallax ? i.transformPerspective = s.transformPerspective.parallax : s.transformPerspective.parallax = i.transformPerspective, i.event.match(/(cursor|scroll)/) || (i.event = "cursor"), i.type.match(/(2d,3d)/) && (i.type = "2d"), i.axis) {
                                case "none":
                                    i.x = !1, i.y = !1;
                                    break;
                                case "x":
                                    i.y = !1;
                                    break;
                                case "y":
                                    i.x = !1
                            }
                            this.wrappers[i.event]["$" + i.type] = this.wrappers[i.event]["$" + i.type].add(t)
                        },
                        addShadow: function() {
                            var t = o.gui.shadow.$element,
                                i = o.slides.current && o.slides.current.parallax ? o.slides.current.index : o.slides.next.index;
                            if (o.slides[i].data.$background && o.slides[i].data.$background.data(o.defaults.init.dataKey).parallax.enabled && o.slides[i].data.overflow && "hidden" !== o.slides[i].data.overflow) {
                                var s, a = "50% -" + .25 * o.slider.height + "px 0",
                                    n = o.slides[i].data.$background.data(o.defaults.init.dataKey).parallax;
                                s = void 0 !== n.rotation ? 2 * n.rotation : void 0 !== o.slides[i].parallax.rotation ? 2 * o.slides[i].parallax.rotation : 2 * this.defaultProperties.rotation, t.data(o.defaults.init.dataKey, {
                                    parallax: e.extend(!0, {}, this.defaultProperties, o.slides[i].parallax, {
                                        level: n.level,
                                        transformOrigin: a,
                                        rotation: s
                                    })
                                }), t.attr("data-ls-parallax", "active"), r.TweenMax.set(t[0], {
                                    transformOrigin: a,
                                    transformPerspective: t.data(o.defaults.init.dataKey).parallax.transformPerspective * o.resize.ratio
                                }), "3d" === o.slides[i].parallax.type || "3d" === n.type ? this.wrappers.cursor.$3d = this.wrappers.cursor.$3d.add(t) : this.wrappers.cursor.$2d = this.wrappers.cursor.$2d.add(t)
                            }
                            this.shadowIsChecked = !0
                        },
                        removeShadow: function() {
                            var e = o.gui.shadow.$element;
                            this.wrappers.cursor.$2d = this.wrappers.cursor.$2d.not(e), this.wrappers.cursor.$3d = this.wrappers.cursor.$3d.not(e), e.attr("data-ls-parallax", "disabled"), this.shadowIsChecked = !1
                        },
                        calculateTransformProperties: function() {
                            e().add(this.wrappers.cursor.$2d).add(this.wrappers.cursor.$3d).add(this.wrappers.scroll.$2d).add(this.wrappers.scroll.$3d).each(function() {
                                var t = e(this).data(o.defaults.init.dataKey).parallax;
                                r.TweenMax.set(e(this)[0], {
                                    transformOrigin: o.functions.convert.transformOrigin(t.transformOrigin, e(this), o.slider.$layersWrapper),
                                    transformPerspective: t.transformPerspective * o.resize.ratio
                                })
                            }), this.transformPropertiesCalculated = !0
                        },
                        deviceTurn: function(e) {
                            if (this.transformPropertiesCalculated) {
                                var t, i, s = window.orientation;
                                0 === s ? (t = 5 * -parseInt(e.gamma) * this.defaults.sensitive * o.resize.ratio, i = 5 * (this.defaults.centerDegree - parseInt(e.beta)) * this.defaults.sensitive * o.resize.ratio) : 90 === s ? (t = 5 * -parseInt(e.beta) * this.defaults.sensitive * o.resize.ratio, i = 5 * (parseInt(e.gamma) + this.defaults.centerDegree) * this.defaults.sensitive * o.resize.ratio) : (t = 5 * parseInt(e.beta) * this.defaults.sensitive * o.resize.ratio, i = 5 * (this.defaults.centerDegree - parseInt(e.gamma)) * this.defaults.sensitive * o.resize.ratio), this.animate2D(t, i, "cursor"), this.animate3D(t, i, "cursor")
                            } else this.calculateTransformProperties();
                            o.slider.state.animatingSlides || this.shadowIsChecked || !o.gui.shadow.$element || this.addShadow()
                        },
                        trigger: function() {
                            e(window).trigger("scroll.parallax" + a), e(window).trigger("touchmove.parallax" + a)
                        },
                        scroll: function() {
                            var e = (("top" === this.defaults.centerLayers ? o.device.winScrollTop : o.device.winScrollTop + (o.device.viewportHeight - o.slider.height) / 2) - o.slider.offsetTop) * o.resize.ratio * this.defaults.scrollModifier;
                            o.slider.state.inFullscreen && (e = 0), this.transformPropertiesCalculated || this.calculateTransformProperties(), this.animate2D(0, e, "scroll"), this.animate3D(0, e, "scroll")
                        },
                        mouseMove: function(e) {
                            if (this.transformPropertiesCalculated) {
                                o.slider.state.animatingSlides || this.shadowIsChecked || !o.gui.shadow.$element || this.addShadow();
                                var t = o.slider.offsetLeft + o.slider.width / 2,
                                    i = o.slider.offsetTop + o.slider.height / 2,
                                    s = e.pageX - t,
                                    a = e.pageY - i;
                                this.animate2D(s, a, "cursor"), this.animate3D(s, a, "cursor")
                            } else this.calculateTransformProperties()
                        },
                        animate2D: function(t, i, s) {
                            this.wrappers[s].$2d.each(function() {
                                var s = e(this);
                                if ("active" === s.attr("data-ls-parallax")) {
                                    var a = s.data(o.defaults.init.dataKey).parallax,
                                        n = a.x ? -t * (a.distance / 2e3) * parseInt(a.level) : 0,
                                        l = a.y ? -i * (a.distance / 2e3) * parseInt(a.level) : 0;
                                    r.TweenMax.to(s[0], a.durationMove, {
                                        x: n,
                                        y: l
                                    })
                                }
                            })
                        },
                        animate3D: function(t, i, s) {
                            this.wrappers[s].$3d.each(function() {
                                var s = e(this);
                                if ("active" === s.attr("data-ls-parallax")) {
                                    var a, n, l, d, u = s.data(o.defaults.init.dataKey).parallax;
                                    u.x ? (n = -t / (4e3 / u.rotation), l = -t * (u.distance / 2e3) * parseInt(u.level)) : (n = 0, l = 0), u.y ? (a = i / (4e3 / u.rotation), d = -i * (u.distance / 2e3) * parseInt(u.level)) : (a = 0, d = 0), r.TweenMax.to(s[0], u.durationMove, {
                                        rotationX: a,
                                        rotationY: n,
                                        x: l,
                                        y: d
                                    })
                                }
                            })
                        },
                        reset: function() {
                            e().add(this.wrappers.cursor.$2d).add(this.wrappers.cursor.$3d).each(function() {
                                var t = e(this);
                                "active" === t.attr("data-ls-parallax") ? r.TweenMax.to(t[0], e(this).data(o.defaults.init.dataKey).parallax.durationLeave, {
                                    x: 0,
                                    y: 0,
                                    rotationX: 0,
                                    rotationY: 0
                                }) : r.TweenMax.set(t[0], {
                                    x: 0,
                                    y: 0,
                                    rotationX: 0,
                                    rotationY: 0
                                })
                            }), o.gui.shadow.$element && this.removeShadow(), this.transformPropertiesCalculated = !1
                        }
                    }, filters: {
                        createTransition: function(e, t, i, s) {
                            var a, r = new o.defaults.layer.properties.filter,
                                n = {};
                            for (a in r) switch (t) {
                                case "in":
                                    n[a] = [r[a], r[a]], n[a][0] = i.hasOwnProperty(a) ? i[a] : s.hasOwnProperty(a) ? s[a] : r[a], n[a][1] = s.hasOwnProperty(a) ? s[a] : r[a], e.filter.values.afterIn[a] = n[a][1];
                                    break;
                                case "hover":
                                case "loop":
                                case "out":
                                    n[a] = [], n[a][0] = i.hasOwnProperty(a) ? i[a] : r[a], n[a][1] = s.hasOwnProperty(a) ? s[a] : i.hasOwnProperty(a) && i[a] !== r[a] ? i[a] : r[a], "loop" === t && !0 !== e.loop.yoyo && -1 !== e.loop.count && (e.filter.values.afterLoop[a] = n[a][1]);
                                    break;
                                case "bg":
                                    n[a] = [r[a], r[a]], i.hasOwnProperty(a) && (n[a][0] = i[a]), s.hasOwnProperty(a) && (n[a][1] = s[a])
                            }
                            return n
                        },
                        convert: function(e) {
                            for (var t, i, s, a = {}, o = /(blur|brightness|contrast|grayscale|hue-rotate|invert|saturate|sepia)/i, r = 0, n = (e = e.split(" ")).length; r < n; r++)(t = (s = e[r].split("("))[0]).match(o) && (i = parseInt(s[1]), a[t] = i);
                            return a
                        },
                        animate: function(e, t) {
                            var i = 100 * e.target[0].p;
                            if ("object" == typeof t) {
                                var s = "";
                                for (var a in t)
                                    if ("object" == typeof t[a] && 2 === t[a].length) switch (a) {
                                        case "blur":
                                            s += " blur( " + (t[a][0] < t[a][1] ? t[a][0] + Math.abs(t[a][0] - t[a][1]) / 100 * i : t[a][0] - Math.abs(t[a][0] - t[a][1]) / 100 * i) + "px )";
                                            break;
                                        case "hue-rotate":
                                            s += " hue-rotate( " + (t[a][0] < t[a][1] ? t[a][0] + Math.abs(t[a][0] - t[a][1]) / 100 * i : t[a][0] - Math.abs(t[a][0] - t[a][1]) / 100 * i) + "deg )";
                                            break;
                                        default:
                                            s += " " + a + "( " + (t[a][0] < t[a][1] ? t[a][0] + Math.abs(t[a][0] - t[a][1]) / 100 * i : t[a][0] - Math.abs(t[a][0] - t[a][1]) / 100 * i) + "% )"
                                    }
                                    r.TweenMax.set(e.target, {
                                    "-webkit-filter": s,
                                    filter: s
                                })
                            }
                        }
                    }, splitType: {
                        setNodesSequence: function(e, t) {
                            var i = t;
                            if ("desc" == e[1]) i = t.slice(0).reverse();
                            else if ("rand" == e[1]) i = t.slice(0).sort(function() {
                                return .5 - Math.random()
                            });
                            else if ("center" == e[1]) {
                                var s, a = Math.floor(t.length / 2);
                                for (i = [t[a]], s = 1; s <= a; s++) i.push(t[a - s], t[a + s]);
                                i.length = t.length
                            } else if ("edge" == e[1]) {
                                var o, r = Math.floor(t.length / 2);
                                for (i = [t[0]], o = 1; o <= r; o++) i.push(t[t.length - o], t[o]);
                                i.length = t.length
                            }
                            return i
                        },
                        resetNodes: function(t, i) {
                            e(".char, .word, .line", t).add(i.elements.$wrapper).css({
                                transform: "none",
                                opacity: 1
                            }).each(function() {
                                delete this._gsTransform
                            })
                        },
                        setRandomProperties: function(e, t, i) {
                            for (var s in t) {
                                for (var a = [], r = 0, n = e.textIn.nodes.length; r < n; r++) a[r] = o.functions.convert.randomProperties(t[s], s);
                                delete i[s], i.cycle[s] = a
                            }
                            t = null
                        }
                    }
                },
                media: {
                    defaults: {
                        delay: 500,
                        fadeIn: 500,
                        fadeOut: 750
                    },
                    changeBackgroundVideo: function(e, t) {
                        if (o.slides.current.index && o.slides.current.data.$backgroundVideo.length) {
                            var s = o.slides.current.data.$backgroundVideo,
                                a = s.data(o.defaults.init.dataKey).elements.$bgWrapper;
                            t && (s.data(o.defaults.init.dataKey).mediaProperties.willBePaused = !0, a.fadeOut(o.transitions.media.defaults.fadeOut, function() {
                                s.trigger("stopBackgroundVideo"), s.data(o.defaults.init.dataKey).mediaProperties.willBePaused = !1
                            }))
                        }
                        if (o.slides.next.data.$backgroundVideo.length) {
                            var r = o.slides.next.data.$backgroundVideo,
                                n = r.data(o.defaults.init.dataKey).elements.$bgWrapper,
                                l = r.data(o.defaults.init.dataKey).elements.$bgOuterWrapper;
                            o.device.isMobile && (i.hasClass("ls-device-is-phone") && l.hasClass("ls-hide-on-phone") || i.hasClass("ls-device-is-tablet") && l.hasClass("ls-hide-on-tablet")) || setTimeout(function() {
                                r.trigger("playBackgroundVideo")
                            }, e ? 50 : 0), e || t ? n.fadeIn(o.transitions.media.defaults.fadeOut) : n.css({
                                display: "block"
                            }), r.data(o.defaults.init.dataKey).mediaProperties.isPreloaded = !0
                        }
                    }
                },
                timers: {
                    defaults: {
                        fadeInDuration: .35,
                        reverseDuration: .3
                    },
                    create: function(e) {
                        this.curNext = e || "next", this.reset(), o.gui.timers.bar.$element && this.bar.createTransition(), o.gui.timers.circle.$element && this.circle.createTransition(), o.gui.timers.slidebar.$element && this.slidebar.createTransition()
                    },
                    reverse: function() {
                        if (o.slides.current && o.slides.current.data && o.transitions._slideTimeline) {
                            var e = o.transitions._slideTimeline.progress(),
                                t = o.slides.current.data.duration * e / this.defaults.reverseDuration;
                            o.gui.timers.bar.$element && this.bar._transition && (o.transitions._slideTimeline.remove(o.transitions.timers.bar._transition), this.bar._transition.reverse().timeScale(t)), o.gui.timers.circle.$element && this.circle._transition && (o.transitions._slideTimeline.remove(o.transitions.timers.circle._transition), this.circle._transition.reverse().timeScale(t)), o.gui.timers.slidebar.$element && this.slidebar._transition && (o.transitions._slideTimeline.remove(o.transitions.timers.slidebar._transition), this.slidebar._transition.reverse().timeScale(t))
                        }
                    },
                    reset: function() {
                        o.gui.timers.bar.$element && this.bar._transition && this.bar.reset(), o.gui.timers.circle.$element && this.circle._transition && this.circle.reset(), o.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 = r.TweenMax.fromTo(o.gui.timers.bar.$element[0], o.slides[o.transitions.curNext].data.duration, {
                                autoCSS: !1,
                                paused: !0,
                                css: {
                                    width: 0
                                }
                            }, {
                                autoCSS: !1,
                                css: {},
                                ease: r.Linear.easeNone,
                                onReverseComplete: function() {
                                    o.transitions.timers.bar._transition = !1
                                },
                                onComplete: function(e) {
                                    e.target.style.width = "100%", e.target.style.width = "calc( 100% - " + o.slider.initial.skinWidth + "px )"
                                },
                                onCompleteParams: ["{self}"],
                                onUpdate: function(e) {
                                    e.target.style.width = Math.min(o.slider.width, o.slider.width * e.progress()) + "px"
                                },
                                onUpdateParams: ["{self}"]
                            })
                        }
                    },
                    circle: {
                        reset: function() {
                            this._transition && (o.gui.timers.circle.$element.stop(!0, !0), this._transition.kill(), this._transition = !1)
                        },
                        createTransition: function() {
                            var e = o.gui.timers.circle.$element.find(".ls-ct-right .ls-ct-rotate")[0],
                                t = o.gui.timers.circle.$element.find(".ls-ct-left .ls-ct-rotate")[0],
                                i = o.slides[o.transitions.curNext].data.duration;
                            this._transition = new r.TimelineMax({
                                paused: !0
                            }).fromTo(o.gui.timers.circle.$element[0], o.transitions.timers.defaults.fadeInDuration, {
                                autoCSS: !1,
                                immediateRender: !0,
                                css: {
                                    opacity: 0,
                                    display: "block"
                                }
                            }, {
                                autoCSS: !1,
                                css: {
                                    opacity: o.gui.timers.circle.$element.data("original").opacity
                                }
                            }).fromTo(e, i / 2, {
                                autoCSS: !1,
                                css: {
                                    rotation: 0
                                }
                            }, {
                                autoCSS: !1,
                                css: {
                                    rotation: 180
                                },
                                ease: r.Linear.easeNone
                            }, 0).fromTo(t, i / 2, {
                                autoCSS: !1,
                                css: {
                                    rotation: 0
                                }
                            }, {
                                autoCSS: !1,
                                css: {
                                    rotation: 180
                                },
                                ease: r.Linear.easeNone
                            }, i / 2)
                        }
                    },
                    slidebar: {
                        reset: function() {
                            this._transition && (this._transition.kill(), this._transition = !1)
                        },
                        createTransition: function() {
                            var t = this;
                            t._transition = new r.TimelineMax({
                                paused: !0,
                                onReverseComplete: function() {
                                    o.transitions.timers.slidebar._transition = !1
                                }
                            }), e.each(o.gui.timers.slidebar.$sliderContainerElement, function(e, i) {
                                t._transition.add(r.TweenMax.fromTo(o.gui.timers.slidebar.$sliderContainerElement[e][0], o.slides[o.transitions.curNext].data.duration, {
                                    autoCSS: !1,
                                    css: {
                                        left: 0
                                    }
                                }, {
                                    autoCSS: !1,
                                    css: {},
                                    ease: r.Linear.easeNone,
                                    onComplete: function(t) {
                                        t.target.style.left = "calc( 100% - " + o.gui.timers.slidebar.sliderContainerElementWidth[e] + "px )"
                                    },
                                    onCompleteParams: ["{self}"],
                                    onUpdate: function(t) {
                                        t.target.style.left = (o.gui.timers.slidebar.containerElementWidth[e] - o.gui.timers.slidebar.sliderContainerElementWidth[e]) * t.progress() + "px"
                                    },
                                    onUpdateParams: ["{self}"]
                                }), 0), t._transition.add(r.TweenMax.fromTo(o.gui.timers.slidebar.$progressBarElement[e][0], o.slides[o.transitions.curNext].data.duration, {
                                    autoCSS: !1,
                                    css: {
                                        width: 0
                                    }
                                }, {
                                    autoCSS: !1,
                                    css: {},
                                    ease: r.Linear.easeNone,
                                    onComplete: function(e) {
                                        e.target.style.width = "100%"
                                    },
                                    onCompleteParams: ["{self}"],
                                    onUpdate: function(t) {
                                        t.target.style.width = o.gui.timers.slidebar.elementWidth[e] * t.progress() + "px"
                                    },
                                    onUpdateParams: ["{self}"]
                                }), 0)
                            })
                        }
                    }
                }
            }, o.plugins = {
                load: function() {
                    if (o.o.plugins && 0 !== o.o.plugins.length) {
                        var t = o.o.plugins[0],
                            i = "object" == typeof t ? t.namespace : t;
                        if (window._layerSlider.plugins[i]) o.plugins.init(i, t, !0), o.plugins.load();
                        else if (o.browser.usesFileProtocol || "object" != typeof t) o.browser.usesFileProtocol ? (window.console && (console.error(o.defaults.slider.errorText, "Cannot load plugins on file:// protocol."), console.info("Please include the plugin files manually.")), o.o.plugins.splice(0, 1), o.plugins.load()) : (window.console && (console.error(o.defaults.slider.errorText, "Plugin files are missing!"), console.info('Plugin "' + i + '" has been added in slider init options, but the source files are not found on page.')), o.o.plugins.splice(0, 1), o.plugins.load());
                        else {
                            if (-1 !== window._layerSlider.pluginsBeingLoaded.indexOf(i)) return void o.plugins.checkLoaded(i); - 1 === window._layerSlider.pluginsLoaded.indexOf(i) && -1 === window._layerSlider.pluginsNotLoaded.indexOf(i) ? (window._layerSlider.pluginsBeingLoaded.push(i), e.ajax({
                                url: -1 === t.js.indexOf("http://") && -1 === t.js.indexOf("https://") ? (window._layerSlider.pluginsPath ? window._layerSlider.pluginsPath : window._layerSlider.scriptPath + "/../plugins/") + t.js : t.js,
                                dataType: "script",
                                success: function() {
                                    o.plugins.init(t.namespace, t, !0), window._layerSlider.pluginsLoaded.push(i)
                                },
                                error: function(e, t, s) {
                                    window.console && (console.error(o.defaults.slider.errorText, i, "plugin has not been loaded!"), console.error("Additional error info:", s)), window._layerSlider.pluginsNotLoaded.push(i)
                                },
                                complete: function() {
                                    window._layerSlider.pluginsBeingLoaded.splice(window._layerSlider.pluginsBeingLoaded.indexOf(i), 1), o.plugins.load()
                                }
                            })) : (o[i] || -1 !== window._layerSlider.pluginsNotLoaded.indexOf(i) ? o.o.plugins.splice(0, 1) : o.plugins.init(i, t), o.plugins.load())
                        }
                    } else o.slider.check.initialized()
                },
                init: function(t, s, r) {
                    o.initializedPlugins[t] = new window._layerSlider.plugins[t](o, i, a, s.settings), window._layerSlider.checkVersions(o.initializedPlugins[t].pluginData.requiredLSVersion, o.plugin.version) ? (s.css && r && e('<link rel="stylesheet" href="' + (-1 === s.css.indexOf("http://") && -1 === s.css.indexOf("https://") ? (window._layerSlider.pluginsPath ? window._layerSlider.pluginsPath : window._layerSlider.scriptPath + "/../plugins/") + s.css : s.css) + '">').appendTo("head"), o.initializedPlugins[t].init && o.initializedPlugins[t].init()) : window.console && console.error(o.defaults.slider.errorText, t, "plugin has not been loaded! Required LayerSlider version:", o.initializedPlugins[t].pluginData.requiredLSVersion, "(you have:", o.plugin.version + ")"), o.o.plugins.splice(0, 1)
                },
                checkLoaded: function(e) {
                    o.intervals.pluginLoaded = setInterval(function() {
                        -1 === window._layerSlider.pluginsLoaded.indexOf(e) && -1 === window._layerSlider.pluginsNotLoaded.indexOf(e) || -1 !== window._layerSlider.pluginsBeingLoaded.indexOf(e) || (clearInterval(o.intervals.pluginLoaded), delete o.intervals.pluginLoaded, o.plugins.load())
                    }, 100)
                }
            }, o.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(t)) return !1;
                    o.api.hasEvent("sliderWillLoad") && i.triggerHandler("sliderWillLoad"), o.slider.set.global()
                },
                set: {
                    global: function() {
                        if (o.originalMarkup = i[0].outerHTML, o.userInitOptions = o.functions.convert.properties(o.functions.convert.oldProperties(s)), o.meta = {}, o.o = e.extend(!0, {}, o.defaults.init.options, o.userInitOptions), o.o.forceLayersOutDuration /= 1e3, o.o.forceLayersOutDuration = o.o.forceLayersOutDuration > 0 ? o.o.forceLayersOutDuration : .75, o.o.sliderFadeInDuration /= 1e3, window.console && !0 !== o.o.hideWelcomeMessage && !0 !== window._layerSlider.hideWelcomeMessage) {
                            window._layerSlider.hideWelcomeMessage = !0;
                            var t = window.console.info ? "info" : "log";
                            console[t]("LayerSlider", "v" + o.plugin.version, "initialized"), console[t]("Find updates and docs @ https://layerslider.kreaturamedia.com/")
                        }
                        var a = {
                            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], a.js = window._layerSlider.pluginsPath + "debug/layerslider.debug.js", a.css = window._layerSlider.pluginsPath + "debug/layerslider.debug.css"), "object" == typeof o.o.plugins ? o.o.plugins.push(a) : o.o.plugins = [a]), (window._layerSlider.currentScript || window._layerSlider.lsScript) && (window._layerSlider.scriptPath = (window._layerSlider.currentScript || window._layerSlider.lsScript).src.replace(/\\/g, "/").replace(/\/[^\/]*$/, "")), "object" == typeof o.o.plugins ? o.plugins.load() : o.slider.check.initialized()
                    },
                    styles: function() {
                        var s, r, n, l, d, u, p, c, h, m, f, g, v, y, b, S, w, x, T, C, k, I, O = o.slider,
                            L = i.parent(),
                            $ = t.style,
                            B = window.getComputedStyle(t, null),
                            P = parseInt(t.clientWidth),
                            W = parseInt(t.clientHeight),
                            M = parseInt(L.width()),
                            _ = parseInt(L.height()),
                            z = o.o.layersContainerWidth,
                            F = o.o.layersContainerHeight,
                            D = o.o.type.toLowerCase();
                        switch (o.debugMode && o.debug.add("group", "sliderInit.style"), o.o.width ? s = -1 == o.o.width.indexOf("%") ? parseInt(o.o.width) : o.o.width : $.width ? s = -1 == $.width.indexOf("%") ? parseInt($.width) : $.width : z > 0 ? (s = z, o.debugMode && o.debug.add("warn", "sliderInit.noWidth", z)) : (s = P, o.debugMode && o.debug.add("warn", "sliderInit.noWidth2", P)), n = s, o.o.height ? r = -1 == o.o.height.indexOf("%") ? parseInt(o.o.height) : o.o.height : $.height ? r = -1 == $.height.indexOf("%") ? parseInt($.height) : $.height : F > 0 ? (r = F, o.debugMode && o.debug.add("warn", "sliderInit.noHeight", F)) : (r = W, o.debugMode && o.debug.add("warn", "sliderInit.noHeight2", _)), l = r, d = "" !== $.maxWidth ? -1 === $.maxWidth.indexOf("%") ? parseInt($.maxWidth) : $.maxWidth : 0, void 0 === o.userInitOptions.type && (z > 0 && F > 0 || "100%" === s && "100%" === r ? D = "fullsize" : z <= 0 && F <= 0 && (o.o.responsiveUnder <= 0 || o.o.responsiveUnder > 0 && o.o.sliderVersion) ? D = void 0 !== o.o.responsive && !1 === o.o.responsive ? "fixedsize" : "responsive" : o.o.responsiveUnder > 0 && (D = "fullwidth")), D) {
                            case "fullwidth":
                                -1 !== s.indexOf("%") && (o.debugMode && o.debug.add("warn", "sliderInit.percWidth", [D, s, P]), s = P), z <= 0 && (z = s, o.debugMode && o.debug.add("warn", "sliderInit.conWidth", [D, s])), o.o.responsiveUnder <= 0 && (o.o.responsiveUnder = z, o.debugMode && o.debug.add("warn", "sliderInit.fullwidth", z)), -1 !== r.indexOf("%") && (p = _ / (100 / parseInt(r)), o.debugMode && o.debug.add("warn", "sliderInit.fullwidth2", [D, r, p]), r = p), F <= 0 && (F = r);
                                break;
                            case "fullsize":
                                -1 !== s.indexOf("%") && (u = z > 0 ? z : M, o.debugMode && o.debug.add("warn", "sliderInit.fullsize", [D, s, u, M, z]), s = u), z <= 0 && (z = s, o.debugMode && o.debug.add("warn", "sliderInit.conWidth", [D, s])), -1 !== r.indexOf("%") && (p = F > 0 ? F : e(window).height() / (100 / parseInt(r)), o.debugMode && o.debug.add("warn", "sliderInit.fullsize2", [D, r, p, e(window).height(), F]), r = p), F <= 0 && (F = r, o.debugMode && o.debug.add("warn", "sliderInit.conHeight", [D, r]));
                                break;
                            case "fixedsize":
                                break;
                            default:
                                o.userInitOptions.type = o.o.type = D = "responsive", o.o.responsiveUnder = -1, -1 !== s.indexOf("%") && (s = P, o.debugMode && o.debug.add("warn", "sliderInit.percWidth", [D, s, P])), -1 !== r.indexOf("%") && (s = W, o.debugMode && o.debug.add("warn", "sliderInit.responsive", [D, r, W])), o.debugMode && z > 0 && o.debug.add("warn", "sliderInit.conWidth2", [D, z]), o.debugMode && F > 0 && o.debug.add("warn", "sliderInit.conHeight2", [D, F])
                        }
                        i.addClass("ls-container ls-" + D), i.parent().addClass("ls-direction-fix"), o.o.preventSliderClip && o.o.fitScreenWidth && ("fullwidth" === D || "fullsize" === D && "fitheight" !== o.o.fullSizeMode) && i.parents(":not(body, html)").each(function() {
                            e(this).addClass("ls-overflow-visible")
                        }), o.userInitOptions.slideBGSize || "responsive" !== D || !o.userInitOptions.hasOwnProperty("sliderVersion") || o.userInitOptions.sliderVersion || (o.o.slideBGSize = "auto", o.debugMode && o.debug.add("warn", "sliderInit.bgCover", D)), o.o.slideBGSize = o.o.slideBGSize.replace("100% 100%", "stretch"), c = z > 0 ? z : s, h = F > 0 ? F : r, "auto" === (g = t.style.marginLeft) ? m = "auto" : "" === g ? m = parseInt(B.getPropertyValue("margin-left")) : m = parseInt(t.style.marginLeft), "auto" === (v = t.style.marginRight) ? f = "auto" : "" === v ? f = parseInt(B.getPropertyValue("margin-right")) : f = parseInt(t.style.marginRight), m === f && ("" === g && "" === v && (y = m, m = "auto", f = "auto"), i.css({
                            marginLeft: "auto",
                            marginRight: "auto"
                        })), b = "" !== $.paddingLeft ? parseInt($.paddingLeft) : parseInt(i.css("padding-left")), w = "" !== $.paddingRight ? parseInt($.paddingRight) : parseInt(i.css("padding-right")), S = "" !== $.paddingTop ? parseInt($.paddingTop) : parseInt(i.css("padding-top")), x = "" !== $.paddingBottom ? parseInt($.paddingBottom) : parseInt(i.css("padding-bottom")), T = "" !== $.borderLeftWidth ? parseInt($.borderLeftWidth) : parseInt(i.css("border-left-width")), k = "" !== $.borderRightWidth ? parseInt($.borderRightWidth) : parseInt(i.css("border-right-width")), C = "" !== $.borderTopWidth ? parseInt($.borderTopWidth) : parseInt(i.css("border-top-width")), I = "" !== $.borderBottomWidth ? parseInt($.borderBottomWidth) : parseInt(i.css("border-bottom-width")), O.initial = {
                            type: D,
                            width: s,
                            height: r,
                            originalWidth: n,
                            originalHeight: l,
                            percW: s / 100,
                            percH: r / 100,
                            layersWidth: z,
                            layersHeight: F,
                            ratio: c / h,
                            maxWidth: d,
                            marginLeft: m,
                            marginRight: f,
                            paddingLeft: b,
                            paddingTop: S,
                            paddingRight: w,
                            paddingBottom: x,
                            borderLeftWidth: T,
                            borderTopWidth: C,
                            borderRightWidth: k,
                            borderBottomWidth: I,
                            skinWidth: b + w + T + k,
                            skinHeight: S + x + C + I
                        }, o.debugMode && (o.debug.add("log", "sliderInit.style", [s, r, n, l, z, F, parseInt(c / h * 100) / 100, d > 0 ? d : void 0, [m, f]]), y && o.debug.add("warn", "sliderInit.margin", y)), e("html").attr("id") ? e("body").attr("id") || e("body").attr("id", "ls-global") : e("html").attr("id", "ls-global"), "static" !== $.position && "absolute" !== $.position && (t.style.position = "relative"), o.o.insertSelector && i[o.o.insertMethod](o.o.insertSelector), o.slider.$hiddenWrapper = e('<div class="ls-wp-container fitvidsignore ls-hidden" data-layerslider-uid="' + a + '"></div>').addClass(i.attr("class")).prependTo("body"), o.slider.$innerWrapper = e('<div class="ls-inner"></div>'), o.slider.$layersWrapper = e('<div class="ls-layers"></div>').appendTo(o.slider.$innerWrapper), o.slider.$bgVideosWrapper = e('<div class="ls-background-videos"></div>').appendTo(o.slider.$layersWrapper), o.slider.$slideBGWrapper = e('<div class="ls-slide-backgrounds"></div>').appendTo(o.slider.$layersWrapper), o.slider.$innerWrapper.appendTo(i), !0 === o.o.hideOnMobile && o.device.isMobile ? (i.addClass("ls-forcehide"), i.closest(".ls-wp-fullwidth-container").addClass("ls-forcehide"), o.o.autoStart = !1) : o.slider.check.showHide(), o.o.globalBGImage && o.slider.$innerWrapper.css({
                            backgroundImage: "url( " + o.o.globalBGImage + " )",
                            backgroundRepeat: o.o.globalBGRepeat,
                            backgroundAttachment: o.o.globalBGAttachment,
                            backgroundSize: o.o.globalBGSize,
                            backgroundPosition: o.o.globalBGPosition
                        }), o.slider.$innerWrapper.css({
                            backgroundColor: o.o.globalBGColor
                        }), "transparent" == o.o.globalBGColor && !1 === o.o.globalBGImage && o.slider.$innerWrapper.css({
                            background: "none transparent"
                        })
                    },
                    options: function() {
                        if (e("html").find('meta[content*="WordPress"]').length && (o.meta.wpVersion = e("html").find('meta[content*="WordPress"]').attr("content").split("WordPress")[1]), e("html").find('script[src*="layerslider"]').length && -1 != e("html").find('script[src*="layerslider"]').attr("src").indexOf("?") && (o.meta.lswpVersion = e("html").find('script[src*="layerslider"]').attr("src").split("?")[1].split("=")[1]), "undefined" != typeof layerSliderTransitions && (o.t = e.extend({}, layerSliderTransitions)), "undefined" != typeof layerSliderCustomTransitions && (o.ct = e.extend({}, layerSliderCustomTransitions)), o.debugMode && ("undefined" != typeof layerCustomSliderTransitions ? (o.debug.add("log", "sliderInit.customTransitions", !1), "undefined" == typeof layerSliderTransitions && o.debug.add("warn", "sliderInit.slideTransitions")) : "undefined" == typeof layerSliderTransitions && o.debug.add("warn", "sliderInit.noSlideTransitions")), "number" == typeof o.o.parallaxCenterDegree && (o.transitions.layers.parallax.defaults.centerDegree = o.o.parallaxCenterDegree), "number" == typeof o.o.parallaxSensitivity && (o.transitions.layers.parallax.defaults.sensitive = o.o.parallaxSensitivity), o.o.parallaxCenterLayers && (o.transitions.layers.parallax.defaults.centerLayers = o.o.parallaxCenterLayers), o.o.playByScroll && (o.o.cycles = -1, o.o.startInViewport = !0, o.o.pauseOnHover = !1, o.o.autoStart = !1), o.o.startInViewport) {
                            if (o.slider.positionToViewport = o.device.winScrollTop > o.slider.offsetTop - (o.device.viewportHeight - o.slider.height) / 2 ? "under" : "over", o.o.playByScroll) {
                                var t, i, s, r = !0,
                                    n = 4 * o.o.playByScrollSpeed;
                                o.device.scroll.timeout = 250, o.transitions.layers.timeline.timeScaleModifier = 0, e(document).on("wheel." + a + " touchmove." + a, function(e) {
                                    o.device.isMobile ? ((t = e.originalEvent.touches[0].clientY) > i ? o.device.scroll.direction = "up" : t < i && (o.device.scroll.direction = "down"), s = i - t, i = t) : (e.originalEvent.deltaY > 0 ? o.device.scroll.direction = "down" : o.device.scroll.direction = "up", s = e.originalEvent.deltaY), 0 !== Math.abs(s) && (o.device.scroll.lastDirection ? o.device.scroll.lastDirection !== o.device.scroll.direction && (o.device.scroll.lastDirection = o.device.scroll.direction, o.transitions.layers.timeline.timeScaleModifier = 0) : o.device.scroll.lastDirection = o.device.scroll.direction, "inside" === o.slider.positionToViewport && (o.resize.viewport(), s >= 0 ? o.transitions.layers.timeline.scrollForward() : o.transitions.layers.timeline.scrollBackwards(), r && (clearTimeout(o.timeouts.scroll), r = !1, o.transitions.layers.timeline.timeScaleModifier = o.transitions.layers.timeline.timeScaleModifier < n ? o.transitions.layers.timeline.timeScaleModifier + .25 : n, o.timeouts.scroll2 = setTimeout(function() {
                                        delete o.timeouts.scroll2, r = !0, o.device.scroll.timeout = o.device.scroll.timeout > 50 ? o.device.scroll.timeout - 50 : 50
                                    }, o.device.scroll.timeout))))
                                })
                            }
                            e(window).on("scroll." + a, function() {
                                o.slider.check.positionToViewport()
                            }), o.timeouts.checkPosition = setTimeout(function() {
                                o.slider.check.positionToViewport()
                            }, 25)
                        }
                        o.slider.canShow = !0
                    }
                },
                check: {
                    initialized: function() {
                        o.debugMode && o.debug.add("log", "sliderInit.info", [o.plugin.version, o.plugin.releaseDate, o.userInitOptions.sliderVersion || "n/a or slider version is pre 6.0.0", i.attr("id"), a, e.fn.jquery, o.meta.lswpVersion, o.meta.wpVersion], !0), o.slider.initialized || (o.slider.initialized = !0, this.skins())
                    },
                    skins: function() {
                        o.o.skin && "" !== o.o.skin && o.o.skinsPath && "" !== o.o.skinsPath ? o.gui.skin.load() : o.slider.init()
                    },
                    showHide: function() {
                        o.device.isMobile && !1 !== o.o.hideOnMobile || (o.device.viewportWidth < o.o.hideUnder || o.device.viewportWidth > o.o.hideOver && o.o.hideOver > 0 ? o.slider.hide() : o.slider.show())
                    },
                    positionToViewport: function() {
                        if (delete o.timeouts.checkPosition, o.o.playByScroll) o.device.scroll.direction && ("down" === o.device.scroll.direction ? o.device.winScrollTop : o.slider.offsetTop - (o.device.viewportHeight - o.slider.height) / 2) > ("down" === o.device.scroll.direction ? o.slider.offsetTop - (o.device.viewportHeight - o.slider.height) / 2 : o.device.winScrollTop) && ("up" === o.device.scroll.direction && "under" === o.slider.positionToViewport || "down" === o.device.scroll.direction && "over" === o.slider.positionToViewport) && (o.slider.positionToViewport = "inside", o.resize.viewport(), o.device.scroll.disable());
                        else {
                            var t = o.device.winScrollTop + o.device.viewportHeight / 2,
                                i = o.slider.offsetTop + o.slider.height / 2;
                            (Math.abs(t - i) < o.device.viewportHeight / 2 || o.device.winScrollTop < o.slider.offsetTop && o.device.winScrollTop + o.device.viewportHeight > o.slider.offsetTop + o.slider.height) && (o.slider.positionToViewport = "inside", e(window).off("scroll." + a), o.debugMode && o.debug.add("log", "slideshow.inviewport", !1), o.transitions._slideTimeline && o.transitions.layers.timeline.play())
                        }
                    }
                },
                init: function() {
                    clearTimeout(o.timeouts.skinLoad1), clearTimeout(o.timeouts.skinLoad2), clearTimeout(o.timeouts.skinLoad3), clearTimeout(o.timeouts.skinLoad4), o.device.setBasicEvents(), o.slider.set.styles(), o.slider.set.options(), o.slides.init(), o.device.fullscreen.set(), o.media.init(), o.gui.timers.init(), o.gui.loadingIndicator.init(), o.preload.init(), o.gui.shadow.init(), o.navigation.init(), o.slideshow.init(), o.slides.set.firstSlide(), o.gui.navigation.init(), o.resize.slider(), o.yourLogo.init(), e(window).on("resize." + a, function() {
                        o.slider.check.showHide(), "inside" === o.slider.positionToViewport && o.o.playByScroll && o.resize.viewport(), o.slider.shouldResize && o.resize.all()
                    }), o.debugMode && (e(window).off(".debug" + a), e(window).on("resize.debug" + a, function() {
                        o.debug.add("log", "resize.window", o.device.viewportWidth, !0)
                    })), e(window).on("orientationchange." + a, function() {
                        o.device.getDimensions(), o.resize.all()
                    }), o.device.getDimensions(), e(window).trigger("resize." + a), e(window).trigger("orientationchange." + a), o.api.hasEvent("sliderDidLoad") && i.triggerHandler("sliderDidLoad", o.api.eventData()), o.functions.setStates(o.slider, {
                        isLoaded: !0
                    }), o.slider.state.shouldBeDestroyed ? o.api.methods("destroy") : o.slideshow.changeTo(o.slides.first.index)
                },
                hide: function() {
                    i.addClass("ls-forcehide"), i.closest(".ls-wp-fullwidth-container").addClass("ls-forcehide")
                },
                show: function() {
                    i.removeClass("ls-forcehide"), i.closest(".ls-wp-fullwidth-container").removeClass("ls-forcehide")
                }
            }, o.functions = {
                convert: {
                    transformOrigin: function(t, i, s) {
                        var a = e.trim(t),
                            r = a.split(" "),
                            n = "",
                            l = ["Left", "Top"],
                            d = [o.slider.width, o.slider.height];
                        a = a.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 u = 0; u < a.length; u++)
                            if (-1 !== r[u].indexOf("slider")) {
                                o.transitions.layers.timeline.shouldRestart = !0;
                                var p = i.data(o.defaults.init.dataKey).elements.$wrapper[0].style;
                                n += u < 2 ? d[u] / (100 / parseInt(a[u])) - parseInt(p[l[u].toLowerCase()]) - parseInt(p["margin" + l[u]]) + "px " : "0px"
                            } else {
                                if (u < 2 && i && s) switch (u) {
                                    case 0:
                                        d = s.width();
                                        break;
                                    case 1:
                                        d = s.height()
                                } - 1 !== a[u].indexOf("%") ? n += u < 2 && i && s ? d / (100 / parseInt(a[u])) + "px " : a[u] + " " : n += parseInt(a[u]) * o.resize.ratio + "px "
                            }
                        return e.trim(n)
                    },
                    easing: function(e, t) {
                        if ("string" == typeof e) {
                            var i, s, a;
                            return e = e.toLowerCase(), -1 !== e.indexOf("swing") || -1 !== e.indexOf("linear") ? i = r.Linear.easeNone : (s = e.match(/(easeinout|easein|easeout)(.+)/)[2], a = r[s.charAt(0).toUpperCase() + s.slice(1)], -1 !== e.indexOf("easeinout") ? i = a.easeInOut : -1 !== e.indexOf("easeout") ? i = t ? a.easeIn : a.easeOut : -1 !== e.indexOf("easein") && (i = t ? a.easeOut : a.easeIn)), i
                        }
                        return e
                    },
                    transition: function(t, i, s, a) {
                        var r = e.extend({}, t),
                            n = {
                                rotate: "rotation",
                                rotateX: "rotationX",
                                rotateY: "rotationY"
                            };
                        return e.each(n, function(e, t) {
                            e in r && (r[t] = r[e], delete r[e])
                        }), "after" === s ? r.scaleX = r.scaleY = r.scaleZ = 1 : r.scale3d !== a && (r.scaleX = r.scaleY = r.scaleZ = r.scale3d, delete r.scale3d), r.delay && (r.delay = "after" === s ? r.delay / 1e3 : r.delay), void 0 === i && (i = "easeInOutQuart"), r.ease = o.functions.convert.easing(i), r
                    },
                    randomProperties: function(e, t) {
                        if (e && -1 !== e.indexOf("(") && -1 !== e.indexOf(",") && -1 !== e.indexOf(")")) {
                            var i = e.split("(")[1].split(")")[0].split(","),
                                s = 1;
                            return i[0] = parseFloat(i[0]), i[1] = parseFloat(i[1]), -1 !== t.indexOf("scale") && (s = 100, i[0] *= s, i[1] *= s), Math.floor(Math.random() * (i[1] - i[0] + 1) + i[0]) / s
                        }
                        return e
                    },
                    properties: function(e, t) {
                        if ("string" == typeof e) return o.functions.convert._properties(e, t);
                        if ("object" == typeof e) {
                            for (var i in e) e[i] = o.functions.convert._properties(e[i], t);
                            return e
                        }
                        return e
                    },
                    _properties: function(t, i) {
                        if ("enable" == t || "enabled" == t || "true" == t) return !0;
                        if ("disable" == t || "disabled" == t || "false" == t) return !1;
                        if ("string" == typeof t && -1 !== t.indexOf(o.defaults.init.lsDataArraySplitChar)) {
                            for (var s = t.split(o.defaults.init.lsDataArraySplitChar), a = [], r = 0; r < s.length; r++) a[r] = e.isNumeric(s[r]) ? parseFloat(e.trim(s[r])) : e.trim(s[r]);
                            return a
                        }
                        return i ? "" + parseInt(t) == "NaN" ? 0 : parseInt(t) : e.isNumeric(t) ? parseFloat(t) : t
                    },
                    oldProperties: function(t) {
                        var i = {
                            firstLayer: "firstSlide",
                            loops: "cycles",
                            forceLoopNum: "forceCycles",
                            layersContainer: "layersContainerWidth",
                            sublayerContainer: "layersContainerWidth",
                            randomSlideshow: "shuffleSlideshow"
                        };
                        return e.each(i, function(e, i) {
                            e in t && (t[i] = t[e], delete t[e])
                        }), t
                    }
                },
                getSliderClosestParentElementWidthNumericValueOfProperty: function(t) {
                    for (var s, a = i.parents(), r = a.length, n = 100, l = 0; l < r; l++)
                        if ("auto" !== (s = window.getComputedStyle(a[l]).getPropertyValue(t))) {
                            if (-1 !== s.indexOf("px")) return o.slider.$parentWithNumericWidthValue = e(a[l]), e(a[l]); - 1 !== s.indexOf("%") && (n = n / 100 * parseInt(s), o.slider.$parentWithNumericWidthValuePercent = n)
                        }
                },
                sortArray: function(e, t, i) {
                    var s = [];
                    if ("forward" == i)
                        for (var a = 0; a < e; a++)
                            for (var o = 0; o < t; o++) s.push(a + o * e);
                    else
                        for (var r = e - 1; r > -1; r--)
                            for (var n = t - 1; n > -1; n--) s.push(r + n * e);
                    return s
                },
                shuffleArray: function(e) {
                    for (var t, i, s = e.length; 0 !== s;) i = Math.floor(Math.random() * s), t = e[s -= 1], e[s] = e[i], e[i] = t;
                    return e
                },
                countProp: function(e) {
                    var t = 0;
                    for (var i in e) e.hasOwnProperty(i) && ++t;
                    return t
                },
                getURL: function(e) {
                    return e[0].currentSrc ? e[0].currentSrc : e.data("src ") ? e.data("src ") : e.attr("src")
                },
                getALT: function(e) {
                    return !!e.attr("alt") && e.attr("alt")
                },
                setStates: function(e, t, s) {
                    if (e && e.state) {
                        var a = o.slideshow.isPaused();
                        if (s) e.state[t] = s;
                        else
                            for (var r in t) e.state[r] = t[r];
                        var n = o.slideshow.isPaused();
                        e == o.slideshow && (o.api.hasEvent("slideshowStateDidChange") && i.triggerHandler("slideshowStateDidChange", o.api.eventData()), n != a && (n ? o.api.hasEvent("slideshowDidPause") && i.triggerHandler("slideshowDidPause", o.api.eventData()) : o.api.hasEvent("slideshowDidResume") && i.triggerHandler("slideshowDidResume", o.api.eventData())))
                    }
                },
                clearTimers: function() {
                    for (var e in o.timeouts) clearTimeout(o.timeouts[e]), delete o.timeouts[e];
                    for (var t in o.intervals) clearInterval(o.intervals[t]), delete o.intervals[t]
                },
                clearTimelines: function() {
                    o.transitions._slideTimeline && (o.transitions._slideTimeline.pause().clear().kill(), delete o.transitions._slideTimeline), o.transitions._forceLayersOut && (o.transitions._forceLayersOut.kill(), delete o.transitions._forceLayersOut), o.transitions._slideTransition && (o.transitions._slideTransition.pause().clear().kill(), delete o.transitions._slideTransition), r.TweenMax.killTweensOf(i.find(".ls-bg, .ls-layer, .ls-wrapper, .ls-curtile, .ls-nexttile").get())
                },
                resetSlideTimelines: function() {
                    o.transitions._slideTimeline && (o.transitions._slideTimeline.pause().progress(0).clear().kill(), delete o.transitions._slideTimeline), o.transitions._forceLayersOut && (o.transitions._forceLayersOut.pause().progress(1).clear().kill(), delete o.transitions._forceLayersOut), i.find(".ls-layer:not(.ls-bg-video)").each(function() {
                        var t = e(this).data(o.defaults.init.dataKey);
                        t.loop._timeline && (t.loop._timeline.stop().clear(), delete t.loop._timeline, r.TweenMax.set(t.elements.$loopWrapper[0], t.reset.loopWrapperOnSlideChange)), r.TweenMax.set(t.elements.$wrapper[0], t.reset.wrapperOnSlideChange)
                    })
                },
                clearEvents: function() {
                    e(window).add("body").add(i).add(i.find("*")).add("." + a).off("." + a + " .debug" + a + " .parallax" + a + " .setter" + a), i.off()
                }
            }, o.device = {
                $overflowWrapper: e(e("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(e) {
                        (e = e || window.event).preventDefault && e.preventDefault(), e.returnValue = !1
                    },
                    preventDefaultForScrollKeys: function(e) {
                        if (-1 !== o.device.scroll.keys.indexOf(e.keyCode)) return o.device.scroll.preventDefault(e), !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" == o.slider.initial.type && "hero" == o.o.fullSizeMode && (o.slider.heroTop = o.slider.offsetTop), o.functions.setStates(o.slider, {
                            inFullscreen: !0
                        }), e("body, html").addClass("ls-fullscreen"), o.slider.fullscreenWrapper.requestFullscreen(), i.trigger("mouseleave"), o.device.removeSelection()
                    },
                    exit: function() {
                        o.functions.setStates(o.slider, {
                            inFullscreen: !1
                        }), o.resize.all(), e("body, html").removeClass("ls-fullscreen"), o.device.removeSelection()
                    },
                    toggle: function() {
                        o.device.fullscreen.element() ? (o.device.fullscreen.exit(), document.exitFullscreen()) : o.device.fullscreen.enter()
                    },
                    set: function() {
                        o.o.allowFullscreen && (document.fullscreenEnabled || document.webkitFullscreenEnabled || document.mozFullScreenEnabled || document.msFullscreenEnabled) && (i.wrap('<div class="ls-fullscreen-wrapper"></div>'), o.slider.$fullscreenWrapper = i.closest(".ls-fullscreen-wrapper"), o.slider.fullscreenWrapper = o.slider.$fullscreenWrapper[0], o.slider.fullscreenWrapper.requestFullscreen = o.slider.fullscreenWrapper.requestFullscreen || o.slider.fullscreenWrapper.webkitRequestFullscreen || o.slider.fullscreenWrapper.mozRequestFullScreen || o.slider.fullscreenWrapper.msRequestFullscreen, document.exitFullscreen = document.exitFullscreen || document.webkitExitFullscreen || document.mozCancelFullScreen || document.msExitFullscreen, e(document).on("fullscreenchange." + a + " webkitfullscreenchange." + a + " mozfullscreenchange." + a + " msfullscreenchange." + a, function() {
                            o.device.fullscreen.element() || o.device.fullscreen.exit()
                        }), o.slider.$fullscreenWrapper.on("dblclick." + a, function() {
                            o.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 = e(window).width(), this.viewportHeight = e(window).height(), this.docWidth = e(document).width(), this.docHeight = e(document).height(), this.winScrollTop = e(window).scrollTop(), this.winScrollLeft = e(window).scrollLeft(), this.ratio = this.width / this.height, o.slider.offsetTop = i.offset().top, o.slider.offsetLeft = i.offset().left
                },
                setBasicEvents: function() {
                    var t, s = this;
                    e(window).on("resize.setter" + a, function() {
                        s.viewportWidth = e(window).width(), s.viewportHeight = e(window).height(), s.ratio = s.width / s.height, o.slider.offsetTop = i.offset().top, o.slider.offsetLeft = i.offset().left
                    }), e(window).on("scroll.setter" + a, function() {
                        s.winScrollTop = e(window).scrollTop(), s.winScrollLeft = e(window).scrollLeft(), o.slider.offsetTop = i.offset().top, o.slider.offsetLeft = i.offset().left
                    }), e(window).on("touchmove", function(e) {
                        s.winScrollTop = window.pageYOffset, s.winScrollLeft = window.pageXOffset, 1 == (t = e.touches ? e.touches : e.originalEvent.touches).length && (s.touchX = t[0].clientX)
                    })
                }
            }, o.api = {
                hasEvent: function(i, s) {
                    var a = e._data(s || t, "events");
                    return !(!a || !a[i])
                },
                methods: function(t, s, r, n) {
                    if (!o.slider.isBusy())
                        if ("number" == typeof t) t > 0 && t < o.slides.count + 1 && t != o.slides.current.index && o.slideshow.changeTo(t, !0, !0);
                        else switch (t) {
                            case "touchPrev":
                                o.device.touchPrev = !0;
                            case "previousSlide":
                            case "prev":
                                o.navigation.prev();
                                break;
                            case "touchNext":
                                o.device.touchNext = !0;
                            case "nextSlide":
                            case "next":
                                o.navigation.next();
                                break;
                            case "startSlideshow":
                            case "start":
                                o.navigation.start()
                        }
                        switch (t) {
                            case "openPopup":
                                o.initializedPlugins.popup && o.initializedPlugins.popup.events.show();
                                break;
                            case "closePopup":
                                o.initializedPlugins.popup && o.initializedPlugins.popup.events.hide();
                                break;
                            case "updateLayerData":
                                s && o.layers.update.data(s, r, n);
                                break;
                            case "redrawSlider":
                            case "redraw":
                                o.resize.all();
                                break;
                            case "replaySlide":
                            case "replay":
                                o.transitions._slideTimeline && (o.transitions._slideTimeline.progress(0), o.transitions._slideTimeline.play());
                                break;
                            case "reverseSlide":
                            case "reverse":
                                o.transitions._slideTimeline && (o.transitions._slideTimeline.reversed() ? o.transitions._slideTimeline.play() : o.transitions._slideTimeline.reverse(), s && (o.transitions.layers.timeline.shouldReplay = !0));
                                break;
                            case "stopSlideshow":
                            case "stop":
                                o.navigation.stop();
                                break;
                            case "pauseSlider":
                            case "pause":
                                o.transitions._slideTimeline && o.transitions._slideTimeline.stop(), o.transitions._slideTransition && o.transitions._slideTransition.stop(), o.media.stop(!1);
                                break;
                            case "resumePopup":
                                o.layers.get("active").each(function() {
                                    o.media.playIfAllowed(e(this))
                                });
                            case "resumeSlider":
                            case "resume":
                                o.transitions._slideTimeline && (o.transitions._slideTimeline.timeScale() < .001 && o.transitions.layers.timeline.resume(), o.transitions._slideTimeline.play()), o.transitions._slideTransition && o.transitions._slideTransition.play();
                                break;
                            case "toggleSlider":
                            case "toggle":
                                o.slider.isPaused ? (i.layerSlider("resume"), o.slider.isPaused = !1) : (i.layerSlider("pause"), o.slider.isPaused = !0);
                                break;
                            case "reset":
                            case "resetSlider":
                                break;
                            case "resetSlide":
                            case "resetCurrentSlide":
                                o.transitions._slideTimeline && (o.transitions._slideTimeline.progress(0), o.transitions._slideTimeline.stop()), o.media.stop(!0);
                                break;
                            case "destroy":
                            case "kill":
                                if (o.slider.state.isLoaded) {
                                    if (o.functions.clearTimers(), o.functions.clearTimelines(), o.layers.$all.removeData(), o.api.hasEvent("sliderDidDestroy") && i.triggerHandler("sliderDidDestroy"), o.slider.state.sholudBeRemoved || s) {
                                        if (o.slider.$hiddenWrapper.remove(), o.gui.timers.slidebar.$containerElement)
                                            for (var l = 0; l < o.gui.timers.slidebar.$containerElement.length; l++) o.gui.timers.slidebar.$containerElement[l] instanceof jQuery && o.gui.timers.slidebar.$containerElement[l].remove();
                                        o.api.hasEvent("sliderDidRemove") && i.triggerHandler("sliderDidRemove"), i.parent(".ls-fullscreen-wrapper").remove()
                                    }
                                    o.functions.clearEvents(), window._layerSlider.removeSlider(a)
                                } else o.functions.setStates(o.slider, {
                                    shouldBeDestroyed: !0,
                                    sholudBeRemoved: s || !1
                                });
                                o.slider.positionToViewport = "under", o.device.scroll.enable()
                        }
                },
                eventData: function() {
                    return {
                        data: o,
                        userData: o.o,
                        uid: a,
                        target: t,
                        slider: i,
                        state: o.slider.state,
                        isBusy: o.slider.isBusy(),
                        api: function(e) {
                            i.layerSlider(e)
                        },
                        slides: {
                            first: {
                                index: o.slides.first.index,
                                deeplink: o.slides.get.deeplink(o.slides.first.index)
                            },
                            prev: {
                                index: o.slides.prev.index,
                                deeplink: o.slides.get.deeplink(o.slides.prev.index)
                            },
                            current: {
                                index: o.slides.current.index || o.slides.first.index,
                                deeplink: o.slides.get.deeplink(o.slides.current.index),
                                layersIn: o.layers.get("current,in"),
                                layersOut: o.layers.get("current,out"),
                                timeline: o.transitions._slideTimeline
                            },
                            next: {
                                index: o.slides.next.index,
                                deeplink: o.slides.get.deeplink(o.slides.next.index),
                                layersIn: o.layers.get("next,in"),
                                layersOut: o.layers.get("next,out")
                            },
                            count: o.slides.count
                        },
                        slideChangeTimeline: o.transitions._slideTransition,
                        slideshow: {
                            state: o.slideshow.state,
                            sequence: o.slideshow.sequence,
                            direction: o.slideshow.direction,
                            isPaused: o.slideshow.isPaused()
                        },
                        cycles: {
                            max: o.o.cycles,
                            current: o.slideshow.curCycle
                        }
                    }
                }
            }, o.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 t = e("<div>"), s = !1, a = !1, o = ["perspective", "OPerspective", "msPerspective", "MozPerspective", "WebkitPerspective"], r = ["transformStyle", "OTransformStyle", "msTransformStyle", "MozTransformStyle", "WebkitTransformStyle"], n = o.length - 1; n >= 0; n--) s = s || void 0 !== t[0].style[o[n]];
                    for (var l = r.length - 1; l >= 0; l--) t.css("transform-style", "preserve-3d"), a = a || "preserve-3d" == t[0].style[r[l]];
                    return s && void 0 !== t[0].style[o[4]] && (t.attr("id", "ls-test3d").appendTo(i), s = 3 === t[0].offsetHeight && 9 === t[0].offsetLeft, t.remove()), s && a
                },
                isOld: -1 !== navigator.userAgent.indexOf("rident/5")
            }, o.initializedPlugins = {}, o.timeouts = {}, o.intervals = {}, o.debug = {
                options: {}
            }, o.plugin = {
                version: "6.6.7",
                releaseDate: "2018. 01. 09."
            }, o.slider.load()
        }
    }(jQuery);
                                    

Executed Writes (0)



HTTP Transactions (172)


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

                                         
                                         35.185.32.196
HTTP/1.1 301 Moved Permanently
Content-Type: text/html
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:20 GMT
Content-Length: 178
Connection: keep-alive
Keep-Alive: timeout=20
Location: https://smarsh.com/
X-Type: default


--- Additional Info ---
Magic:  HTML document text
Size:   178
Md5:    cd2e0e43980a00fb6a2742d3afd803b8
Sha1:   81ffbd1712afe8cdf138b570c0fc9934742c33c1
Sha256: bd9df047d51943acc4bc6cf55d88edb5b6785a53337ee2a0f74dd521aedde87d
                                        
                                            POST / HTTP/1.1 
Host: ocsp.digicert.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

                                         
                                         93.184.220.29
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Accept-Ranges: bytes
Cache-Control: max-age=155878
Date: Sat, 26 May 2018 00:27:21 GMT
Etag: "5b0867cd-1d7"
Expires: Sun, 27 May 2018 19:45:19 GMT
Last-Modified: Fri, 25 May 2018 19:45:17 GMT
Server: ECS (ams/49A4)
X-Cache: HIT
Content-Length: 471


--- Additional Info ---
Magic:  data
Size:   471
Md5:    71b46e5f1f9898642494854e61eb131b
Sha1:   0c67520043f2497ca8ce077bfafc8854c1f483d3
Sha256: 5c85738d84c82af57bf69c3a5e31952e67fdde858b25b580e7ae1474ed125cba
                                        
                                            POST / HTTP/1.1 
Host: ocsp.digicert.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

                                         
                                         93.184.220.29
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Accept-Ranges: bytes
Cache-Control: max-age=162680
Date: Sat, 26 May 2018 00:27:21 GMT
Etag: "5b084bb5-1d7"
Expires: Sun, 27 May 2018 21:12:49 GMT
Last-Modified: Fri, 25 May 2018 17:45:25 GMT
Server: ECS (arn/4692)
X-Cache: HIT
Content-Length: 471


--- Additional Info ---
Magic:  data
Size:   471
Md5:    2da8e1d6d7623a455fa7fb9c1bf19cba
Sha1:   0c8b777bab319ea6772e65d434d5c21326bb0855
Sha256: c4cc46641828f03f65abc54480ee7bcb77d0345663a78b1d52dad36b003b7f5d
                                        
                                            GET / HTTP/1.1 
Host: smarsh.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

                                         
                                         35.185.32.196
HTTP/1.1 301 Moved Permanently
Content-Type: text/html; charset=UTF-8
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:22 GMT
Content-Length: 0
Connection: keep-alive
Keep-Alive: timeout=20
Expires: Thu, 19 Nov 1981 08:52:00 GMT
Pragma: no-cache
Vary: User-Agent
Location: https://www.smarsh.com/
WPE-Backend: apache
X-Cacheable: non200
Cache-Control: max-age=600, must-revalidate
X-Cache: HIT: 1
X-Cache-Group: normal
X-Type: default


--- Additional Info ---
                                        
                                            GET / HTTP/1.1 
Host: www.smarsh.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

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: text/html; charset=UTF-8
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:22 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Expires: Thu, 19 Nov 1981 08:52:00 GMT
Pragma: no-cache
Link: <https://www.smarsh.com/wp-json/>; rel="https://api.w.org/", <https://www.smarsh.com/>; rel=shortlink
WPE-Backend: apache
X-Cacheable: SHORT
Vary: Accept-Encoding,Cookie
Cache-Control: max-age=600, must-revalidate
X-Cache: HIT: 10
X-Cache-Group: normal
X-Type: default
Content-Encoding: gzip


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

                                         
                                         216.58.211.14
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Date: Sat, 26 May 2018 00:27:23 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:    43bfa19fd90960d5574f39d3f46f8f9e
Sha1:   709fadc339ab11ce9a3e38cb36195f7c5048dcef
Sha256: f4be93309b6670916da8321706081095d40d9b1b0a3257311cfb5d9631d8ffcb
                                        
                                            POST /gsr2 HTTP/1.1 
Host: ocsp.pki.goog
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Content-Length: 112
Content-Type: application/ocsp-request

                                         
                                         216.58.211.14
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Date: Sat, 26 May 2018 00:27:23 GMT
Cache-Control: public, max-age=345600
Server: ocsp_responder
Content-Length: 468
X-XSS-Protection: 1; mode=block
X-Frame-Options: SAMEORIGIN


--- Additional Info ---
Magic:  data
Size:   468
Md5:    6bf50ec404fb4a8b4a94be8390d11938
Sha1:   0caaab7704d6221abc5e0342909a4928cee50b1c
Sha256: 63b592179b1e9a528344ce1d430b9479fc55f43420a468ec35aaeaa9dff911cf
                                        
                                            POST / HTTP/1.1 
Host: ocsp.int-x3.letsencrypt.org
                                        
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: 117
Content-Type: application/ocsp-request

                                         
                                         91.135.34.91
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Server: nginx
Content-Length: 527
Etag: "E77AB5DD9FB27EF5C9A25E2AFC44E943BA5B93F1C6FFF7DF9603EB0CD7211B7D"
Last-Modified: Wed, 23 May 2018 22:00:00 UTC
Cache-Control: public, no-transform, must-revalidate, max-age=42516
Expires: Sat, 26 May 2018 12:15:59 GMT
Date: Sat, 26 May 2018 00:27:23 GMT
Connection: keep-alive


--- Additional Info ---
Magic:  data
Size:   527
Md5:    294e32bba18e2b3e33a86ce67e3edc2d
Sha1:   1ff3fb9dad3a2def8503451ca37d40ecf29c5b9c
Sha256: e77ab5dd9fb27ef5c9a25e2afc44e943ba5b93f1c6fff7df9603eb0cd7211b7d
                                        
                                            POST / HTTP/1.1 
Host: isrg.trustid.ocsp.identrust.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

                                         
                                         91.135.34.122
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Content-Transfer-Encoding: Binary
Last-Modified: Wed, 23 May 2018 19:59:20 GMT
Etag: "5247d834180d56a8a5bd7d5d614903409a45e041"
Content-Length: 1398
Cache-Control: public, no-transform, must-revalidate, max-age=23197
Expires: Sat, 26 May 2018 06:54:00 GMT
Date: Sat, 26 May 2018 00:27:23 GMT
Connection: keep-alive


--- Additional Info ---
Magic:  data
Size:   1398
Md5:    ae411a49cfac0288104307eed1c4e1e3
Sha1:   5247d834180d56a8a5bd7d5d614903409a45e041
Sha256: 54bae6bf82d203d3a1cb551e8f79a8ea00278d0ed0f9151278aa9836df18d43f
                                        
                                            GET /css?family=Open+Sans:400,600 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.smarsh.com/

                                         
                                         216.58.211.10
HTTP/1.1 200 OK
Content-Type: text/css; charset=utf-8
                                        
Access-Control-Allow-Origin: *
Timing-Allow-Origin: *
Expires: Sat, 26 May 2018 00:27:23 GMT
Date: Sat, 26 May 2018 00:27:23 GMT
Cache-Control: private, max-age=86400
Content-Encoding: gzip
Server: ESF
X-XSS-Protection: 1; mode=block
X-Frame-Options: SAMEORIGIN
Alt-Svc: hq=":443"; ma=2592000; quic=51303433; quic=51303432; quic=51303431; quic=51303339; quic=51303335,quic=":443"; ma=2592000; v="43,42,41,39,35"
Transfer-Encoding: chunked


--- Additional Info ---
Magic:  gzip compressed data, max compression
Size:   239
Md5:    a3d0ff4986681155ea6a13d395681c9e
Sha1:   c2f2dff2816024ee96b9d66c96af87d804ed4618
Sha256: bd974e286ca5067b27afd7e1d6538febf990224f563be19d5a53d3785d69cbef
                                        
                                            GET /wp-content/uploads/2013/07/favicon.ico HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: image/png,image/*;q=0.8,*/*;q=0.5
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: image/x-icon
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:23 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 20:39:13 GMT
Etag: W/"5a3978f1-47e"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   467
Md5:    b68cc1ea9878588e41a598f04e62dee3
Sha1:   43d127c6b8be89a9210a1b37ce778aad0ca8ab1d
Sha256: 84613e7ea1f2f405466ed4d353b2c3b3bc2dd06c781d6a27c4bf5224c62a3468
                                        
                                            GET /wp-content/plugins/wp_logooos_plugin/css/logos.css?ver=4.9.5 HTTP/1.1 
Host: www.smarsh.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.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:23 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 20:36:21 GMT
Etag: W/"5a397845-2370"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   2146
Md5:    d93dbf17e6ffbc232bb7b494bc11fafe
Sha1:   2c6cd7208a1e3b96a6949d0011fdc6bb0c75a00f
Sha256: 27b63427d084f2afd1557a9f310a6ae1c6ffea5d4c3c7769bc11b6f1566cba1c
                                        
                                            GET /ui/1.11.0/themes/smoothness/jquery-ui.css?ver=4.9.5 HTTP/1.1 
Host: code.jquery.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.smarsh.com/

                                         
                                         205.185.208.52
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Date: Sat, 26 May 2018 00:27:23 GMT
Connection: Keep-Alive
Accept-Ranges: bytes
Content-Encoding: gzip
Content-Length: 7538
Last-Modified: Fri, 24 Oct 2014 00:16:08 GMT
Server: nginx
Vary: Accept-Encoding
Etag: W/"54499a48-8005"
Cache-Control: max-age=315360000
Access-Control-Allow-Origin: *
X-HW: 1527294443.dop013.sk1.t,1527294443.cds042.sk1.shn,1527294443.dop013.sk1.t,1527294443.cds015.sk1.c


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   7538
Md5:    7ab656778118e7a47f96876292d7b5f8
Sha1:   9aefcdc7e4d3e0dfbace064ad10404c0c9baee73
Sha256: 2234853066e40bee98bd0ad4b434a400e4a82dc2f4eed6ccde8fc841b9f34f6d
                                        
                                            GET /ui/1.11.0/jquery-ui.js?ver=4.9.5 HTTP/1.1 
Host: code.jquery.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         205.185.208.52
HTTP/1.1 200 OK
Content-Type: application/javascript; charset=utf-8
                                        
Date: Sat, 26 May 2018 00:27:23 GMT
Connection: Keep-Alive
Accept-Ranges: bytes
Content-Encoding: gzip
Content-Length: 141021
Last-Modified: Fri, 24 Oct 2014 00:16:08 GMT
Server: nginx
Vary: Accept-Encoding
Etag: W/"54499a48-70a4b"
Cache-Control: max-age=315360000
Access-Control-Allow-Origin: *
X-HW: 1527294443.dop013.sk1.t,1527294443.cds042.sk1.shn,1527294443.dop013.sk1.t,1527294443.cds011.sk1.c


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   141021
Md5:    5761d4773080280d7f58a39262883854
Sha1:   c12a71c23ef189065bcb2fb7cf7fdd197d77f24c
Sha256: 516ca184470fb9305475503949e1819d3b22d784b60a7ae45cfcb8f104dff2b1
                                        
                                            POST / HTTP/1.1 
Host: ocsp.comodoca4.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

                                         
                                         91.135.34.19
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Server: Apache
Last-Modified: Fri, 25 May 2018 22:26:03 GMT
Etag: 6ACA0F923E215C5A112F7265478F2B1B41312F93
X-OCSP-Responder-ID: rmdccaocsp4
Content-Length: 471
Cache-Control: public, no-transform, must-revalidate, max-age=1173
Expires: Sat, 26 May 2018 00:46:56 GMT
Date: Sat, 26 May 2018 00:27:23 GMT
Connection: keep-alive


--- Additional Info ---
Magic:  data
Size:   471
Md5:    9e8f17e31b86498ea5dbcc0e8ba293f6
Sha1:   6aca0f923e215c5a112f7265478f2b1b41312f93
Sha256: d36bea5915da6d5e02afe0664bad24e707ac0e2b6211f9e11d3e604422159034
                                        
                                            POST / HTTP/1.1 
Host: ocsp.comodoca4.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

                                         
                                         91.135.34.19
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Server: Apache
Last-Modified: Fri, 25 May 2018 21:10:02 GMT
Etag: C3694309759155D3EAA18087DC13E710F0F54F85
X-OCSP-Responder-ID: rmdccaocsp21
Content-Length: 727
Cache-Control: public, no-transform, must-revalidate, max-age=851
Expires: Sat, 26 May 2018 00:41:34 GMT
Date: Sat, 26 May 2018 00:27:23 GMT
Connection: keep-alive


--- Additional Info ---
Magic:  data
Size:   727
Md5:    a6277e172cc64a0413609d484ecc09ad
Sha1:   c3694309759155d3eaa18087dc13e710f0f54f85
Sha256: c9e62617df4d891ed6aea2308050ce3be503879a66f858c80f8999f8b94a4186
                                        
                                            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: Sat, 26 May 2018 00:27:23 GMT
Server: Apache
Last-Modified: Fri, 25 May 2018 21:10:02 GMT
Expires: Fri, 01 Jun 2018 21:10:02 GMT
Etag: 3661FA59AA38A41AF971A2554DD22C31FD1F3F96
Cache-Control: max-age=592358,public,no-transform,must-revalidate
X-OCSP-Responder-ID: rmdccaocsp7
Content-Length: 471
Connection: close


--- Additional Info ---
Magic:  data
Size:   471
Md5:    e08c5d1a99e0420b69c8dbb6e3796060
Sha1:   3661fa59aa38a41af971a2554dd22c31fd1f3f96
Sha256: eaaf7ce43c94fbefd7f62068d7ae06bb400e665aeedf317db5bdffb9b25de11f
                                        
                                            GET /wp-content/plugins/types-access/vendor/toolset/toolset-common/res/lib/font-awesome/css/font-awesome.min.css?ver=4.7.0 HTTP/1.1 
Host: www.smarsh.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.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:23 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 16 Jan 2018 16:06:24 GMT
Etag: W/"5a5e2300-7918"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   7949
Md5:    7438a1154022437d28516126856bdc9c
Sha1:   02de5513d5eaa24de95874d298d91e7bfae82568
Sha256: 598f569294373e51127d419bcd5da11da3d104a6db21dc45fb7dc80fd7d2bd02
                                        
                                            GET /wp-content/plugins/chart-plugin/public/assets/css/public.css?ver=1.7.4 HTTP/1.1 
Host: www.smarsh.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.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:23 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 20:54:28 GMT
Etag: W/"5a397c84-13f7"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   885
Md5:    09071a839f4af7108711bc8282fc9ad3
Sha1:   814226e282f158d3cdafeb9203fa4ce0dc1609a1
Sha256: 229b24eab42f4e55f47abcd04f2ae6540f6030488315a31d408d56020bd98338
                                        
                                            GET /wp-content/themes/enfold/config-layerslider/LayerSlider/static/layerslider/css/layerslider.css?ver=6.6.7 HTTP/1.1 
Host: www.smarsh.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.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:23 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Fri, 26 Jan 2018 01:47:19 GMT
Etag: W/"5a6a88a7-528d"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   4824
Md5:    84855e1e54520466ca0b69e7bbe49089
Sha1:   5edef607752281329e31b68a59e35c93b9c66d5e
Sha256: d5830f5fe335e0d4189c05388882af69a801786def54405c0719532ebcbb6cc3
                                        
                                            GET /wp-content/plugins/print-o-matic/css/style.css?ver=1.2 HTTP/1.1 
Host: www.smarsh.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.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:23 GMT
Content-Length: 841
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 20:36:21 GMT
Etag: "5a397845-349"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text, with CRLF line terminators
Size:   841
Md5:    84335798544c740ab6354433ed13d2b2
Sha1:   5a2aa93823afbb79a984941003dc7ea670788cd8
Sha256: 504c0bfcb5fcf99f19be89a08ecffeae8061c0bd75e10162245b7069905cae9d
                                        
                                            GET /wp-content/plugins/smarsh-shortcode/css/style.css?v=1.1&ver=4.9.5 HTTP/1.1 
Host: www.smarsh.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.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:23 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 21:14:42 GMT
Etag: W/"5a398142-ae2"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   981
Md5:    ce36c5734072d2544837e7656abe8891
Sha1:   12c227f63f3edf9b067e9f2af35ace984c46e512
Sha256: c55ad489ec8f297dc85a5bf1d0f67d3526ea889eab273ab773ef26d23bf83cc1
                                        
                                            GET /ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css?ver=4.7 HTTP/1.1 
Host: cdnjs.cloudflare.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.smarsh.com/

                                         
                                         104.19.197.151
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Date: Sat, 26 May 2018 00:27:23 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Last-Modified: Mon, 24 Oct 2016 16:31:35 GMT
Expires: Thu, 16 May 2019 00:27:23 GMT
Cache-Control: public, max-age=30672000
Access-Control-Allow-Origin: *
Content-Encoding: gzip
CF-Cache-Status: HIT
Vary: Accept-Encoding
Strict-Transport-Security: max-age=15780000; includeSubDomains
Expect-CT: max-age=604800, report-uri="https://report-uri.cloudflare.com/cdn-cgi/beacon/expect-ct"
Server: cloudflare
CF-RAY: 420c1da19cfa4267-OSL


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   7102
Md5:    f529ce613d8baf3f3cccfd46f03a084d
Sha1:   84ef851e9885ccc24911e5c03f1cc0d094959cd3
Sha256: ad0cc939bf160d744317828d29614b37cde0ba0ef08365d8f8b919fe89df3caf
                                        
                                            GET /wp-content/plugins/fooboxV2/css/foobox.min.css?ver=2.4.0.0 HTTP/1.1 
Host: www.smarsh.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.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:23 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 20:35:51 GMT
Etag: W/"5a397827-1c2af"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   16667
Md5:    dff84e43c4a98af1baa55bf0fc07affc
Sha1:   35038f4c5c3aee3f09f586c6f948962e1d48e1ad
Sha256: b35b4aaad1be8ccbbce21fc582d97c17960cb12cce636c7b5fec601700f5f04e
                                        
                                            GET /wp-includes/js/mediaelement/mediaelementplayer-legacy.min.css?ver=4.2.6-78496d1 HTTP/1.1 
Host: www.smarsh.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.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:23 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Mon, 28 Aug 2017 19:29:47 GMT
Etag: W/"59a46f2b-2be0"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   3003
Md5:    872c128b2d89aac4734bca127a3cf519
Sha1:   b41b5e8dd0d29cdcf2c4ef20b04603b6caa5f78b
Sha256: 1e3c0c94e2fcc1f755293326d1ea2b614ab656e991fee24d21741b36a7cf82fd
                                        
                                            GET /wp-includes/js/mediaelement/wp-mediaelement.min.css?ver=4.9.5 HTTP/1.1 
Host: www.smarsh.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.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:23 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Mon, 16 Oct 2017 23:02:47 GMT
Etag: W/"59e53a97-fe4"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   1289
Md5:    33709ace51af989e70bede097c613e9e
Sha1:   d61b9527a547cd7570d5d98ac68ece7c81568566
Sha256: 9e523e1c33e270b63b9df523693ede1f2235e17b9d626e5d9638a02780101f85
                                        
                                            GET /wp-content/themes/enfold/css/grid.css?ver=4.2.2 HTTP/1.1 
Host: www.smarsh.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.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:23 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Fri, 26 Jan 2018 01:47:19 GMT
Etag: W/"5a6a88a7-2510"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   2464
Md5:    824671de96f4ced8dbc61fda68ced158
Sha1:   8cd30697b5ec017215dd360d0d57164a9105e8b2
Sha256: 8c7d814523f98ac4cd604e73759b353c56c4077f8bcbd7e0fc8e91294e8d73f3
                                        
                                            GET /wp-content/themes/enfold/css/base.css?ver=4.2.2 HTTP/1.1 
Host: www.smarsh.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.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:23 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Fri, 26 Jan 2018 01:47:19 GMT
Etag: W/"5a6a88a7-38a5"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   4607
Md5:    9e92f81873bbe8f4b9198f33816a9414
Sha1:   fe4758abec0c297ecc4bd4e64b5a476259c116d1
Sha256: 758c7e5d8841388d661e837aeaac274b033f31bb7c4405c799a0f254613512df
                                        
                                            GET /wp-content/themes/enfold/css/print.css?ver=4.2.2 HTTP/1.1 
Host: www.smarsh.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.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:23 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Fri, 26 Jan 2018 01:47:19 GMT
Etag: W/"5a6a88a7-12fa"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   1808
Md5:    8f4b5ff9fe03f46b62ca6d96236a57df
Sha1:   4114f411cfa63842a2e923514e16e5187b7ceff5
Sha256: 390902becf3b38d99518e23d16cab24ff1d3333425174c00e58c4c527ec12058
                                        
                                            GET /wp-content/themes/enfold/css/custom.css?ver=4.2.2 HTTP/1.1 
Host: www.smarsh.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.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:23 GMT
Content-Length: 707
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Fri, 26 Jan 2018 01:47:19 GMT
Etag: "5a6a88a7-2c3"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII C program text
Size:   707
Md5:    1877fc72c3a2a4e3f1299ccdb16d0513
Sha1:   3b13b3570948b77a60c65c72d561c47f67452e4a
Sha256: cb04c84b625847684f6b428b2acc5772b549e12d18acf8ca9b6a356cdb661fbc
                                        
                                            GET /wp-content/themes/enfold/css/layout.css?ver=4.2.2 HTTP/1.1 
Host: www.smarsh.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.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:23 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Fri, 26 Jan 2018 01:47:19 GMT
Etag: W/"5a6a88a7-1c956"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   29365
Md5:    3fe07ce019610d6c2485332fd5ab2035
Sha1:   4609fe7a27adf7085ce53f29792014db66267329
Sha256: d925adcdb1e429dc79df0127ec878452f2540df3ecdc438f2c997f4cbdf3fd22
                                        
                                            GET /wp-content/themes/enfold/css/shortcodes.css?ver=4.2.2 HTTP/1.1 
Host: www.smarsh.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.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:23 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Fri, 26 Jan 2018 01:47:19 GMT
Etag: W/"5a6a88a7-2f587"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   44109
Md5:    956a2b0b498b290cb8f979f57d11f74d
Sha1:   103a14bcee7d54aa8e600d6796f7f369ad45176a
Sha256: c7b3f8ba5ae803d0c7fc9b8be6211076ad12222efb91ebb6c566e36c96b89809
                                        
                                            GET /wp-content/uploads/dynamic_avia/smarsh.css?ver=5ac2b0178d8ba HTTP/1.1 
Host: www.smarsh.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.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:23 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Mon, 02 Apr 2018 22:35:03 GMT
Etag: W/"5ac2b017-24668"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   24423
Md5:    e6f19d5fd92e05e32e59a4701f284bb6
Sha1:   534c8f14556dd031d2dd487071873d3f70d7d859
Sha256: 02440d6c5e4794afb47492294327d9e3db980220cce72cc0963ca8d7d00b427d
                                        
                                            GET /wp-content/themes/enfold/config-gravityforms/gravity-mod.css?ver=1 HTTP/1.1 
Host: www.smarsh.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.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Fri, 26 Jan 2018 01:47:19 GMT
Etag: W/"5a6a88a7-f06"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   741
Md5:    d4ba58de39a9f1a563ebff71ca22e44e
Sha1:   892dce7e2b9efd583fbd039a987cc836ae48a432
Sha256: 3f232a70f73325b0af249286932024966e4c2e8ce594bf816bf7b373a60706aa
                                        
                                            GET /wp-content/plugins/dk-pdf/assets/css/frontend.css?ver=1.9.3 HTTP/1.1 
Host: www.smarsh.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.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Content-Length: 315
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 20:53:47 GMT
Etag: "5a397c5b-13b"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text
Size:   315
Md5:    914fd5f92aaf090a24d01bd5ce50883e
Sha1:   06ba47d5278160a2820a319457a3523af9389666
Sha256: 0bf507ba3142aa3a2f4bf435023785c182903f6e343b8dc099867245454c577c
                                        
                                            GET /wp-content/themes/smarsh/style.css?ver=4.2.2 HTTP/1.1 
Host: www.smarsh.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.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:23 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Fri, 25 May 2018 04:15:33 GMT
Etag: W/"5b078de5-25161"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   40561
Md5:    0f2dfb841e929a6bba1c483d374334a3
Sha1:   99606cb622696bc165950f265deefe7de770267b
Sha256: a933c61800b95743e9ee7b071cf5e640e76a40e9f267088b952587b89474fde4
                                        
                                            GET /wp-includes/js/jquery/jquery-migrate.min.js?ver=1.4.1 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Fri, 20 May 2016 06:11:28 GMT
Etag: W/"573eaa90-2748"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   4306
Md5:    263da3c76e040de59141e13a36a27c8e
Sha1:   10bf87dfc02978dd1263fe427486376257f0d83c
Sha256: fa39bcd1ae1adf5df39a3e13c630e184f15ad85330112cb61e1ffcea4c55a376
                                        
                                            GET /css?family=Open+Sans:300 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.smarsh.com/wp-content/themes/smarsh/style.css?ver=4.2.2

                                         
                                         216.58.211.10
HTTP/1.1 200 OK
Content-Type: text/css; charset=utf-8
                                        
Access-Control-Allow-Origin: *
Timing-Allow-Origin: *
Expires: Sat, 26 May 2018 00:27:24 GMT
Date: Sat, 26 May 2018 00:27:24 GMT
Cache-Control: private, max-age=86400
Content-Encoding: gzip
Server: ESF
X-XSS-Protection: 1; mode=block
X-Frame-Options: SAMEORIGIN
Alt-Svc: hq=":443"; ma=2592000; quic=51303433; quic=51303432; quic=51303431; quic=51303339; quic=51303335,quic=":443"; ma=2592000; v="43,42,41,39,35"
Transfer-Encoding: chunked


--- Additional Info ---
Magic:  gzip compressed data, max compression
Size:   201
Md5:    15cf80a4e8f280f780a0fdc257dd3950
Sha1:   957113e52dc8fc0bbd849d39d8e243e3abd68bb1
Sha256: 1cb7c017ab0b138bf945f4f1f12f4cbbcc29ec319d5b19a9ca6feba433702cd5
                                        
                                            GET /wp-content/plugins/smarsh-shortcode/js/dateform.js?ver=4.9.5 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Content-Length: 979
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 21:14:50 GMT
Etag: "5a39814a-3d3"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text
Size:   979
Md5:    ce844db99269b374e7fa1b4370143d36
Sha1:   e2d446fad073b0fc101598fa640899414fa757ba
Sha256: 6253d927397158fb5084ec625b62934e2f9b0de2b7f54c9ec4adce15d7344548
                                        
                                            GET /wp-content/plugins/smarsh-shortcode/js/jquery.expander.js?ver=4.9.5 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 21:14:55 GMT
Etag: W/"5a39814f-34c5"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   4755
Md5:    2abedd422a01e84736434f06afa1ce57
Sha1:   526f91d278a4ec95cd4bd0334ddf46cdaf06475f
Sha256: 7c10260c172dc4cf1496c6cbd6ac4850d42fe85708bf264899580e172414f552
                                        
                                            GET /wp-content/plugins/smarsh-shortcode/js/jquery.functions.js?ver=4.9.5 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Thu, 24 May 2018 23:57:49 GMT
Etag: W/"5b07517d-c5a"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   1322
Md5:    7ffca5b352f8b501b4c330155c21ca96
Sha1:   0620797c73fc6b500b11536e924ac02c1552837b
Sha256: af937376048e5c331c3baa8e3de0faca387ad951b7afb28841fe15554d23c041
                                        
                                            GET /wp-includes/js/jquery/jquery.js?ver=1.12.4 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Mon, 23 May 2016 09:00:29 GMT
Etag: W/"5742c6ad-17ba0"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   39407
Md5:    52e2b84578787767c3c49a3b193b94a4
Sha1:   99a84318ca297a4d061b7008e1c3e3e806a79d3c
Sha256: d9a40b219cc9307378ddb0cd864a73518bb83a249abdf3ef0edbeb8c3eca79df
                                        
                                            GET /wp-content/plugins/smarsh-shortcode/js/jquery.columns.js?ver=4.9.5 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 21:14:51 GMT
Etag: W/"5a39814b-7ed"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   514
Md5:    d650bb3f0f4551e2a5135b99467a0721
Sha1:   7f66c825a57c0834c533208cc864dafb3f3036e7
Sha256: fed25ebd96d50b413ef733d19e21d5f02fd2bfd52be846745375e393c746dbc7
                                        
                                            GET /wp-content/plugins/smarsh-shortcode/js/boom.init.js?ver=4.9.5 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Wed, 14 Feb 2018 14:34:24 GMT
Etag: W/"5a8448f0-92d"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   831
Md5:    61e0981c3661a2c90102709b6510768b
Sha1:   0953c4d9b4c59735ed9995bd6eb65aac27baf816
Sha256: 42fc2dc912e0fccd4fc695bc26ee12494711b58a1df9c351676054bf3bccb207
                                        
                                            GET /wp-content/plugins/smarsh-shortcode/js/jquery.dotdotdot.js?ver=4.9.5 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 21:14:54 GMT
Etag: W/"5a39814e-3cb8"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   5433
Md5:    4c313d81a7e798af4e294235648a2b62
Sha1:   b032e10ae7afebb88c04560e06fc2c8ed98e7dd6
Sha256: d76e369592cb29962a2ffe2a4d514d26f4c8df3b6cba947e4d53d17690c6d1fb
                                        
                                            GET /wp-content/plugins/smarsh-shortcode/js/jquery.facetfilter.js?ver=4.9.5 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 21:14:56 GMT
Etag: W/"5a398150-4da"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   597
Md5:    bd02616b0b748787fb47df6f2d40eda8
Sha1:   50afda57f5f81d75859d2a964c9f6240da88fccb
Sha256: 8c6faa4d1f107b3c78429a04f85a40f8a31287878615b17bb0f113182a6e0461
                                        
                                            GET /wp-content/plugins/smarsh-shortcode/js/jquery.forms.js?ver=4.9.5 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Fri, 02 Mar 2018 00:09:27 GMT
Etag: W/"5a989637-1133"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   1290
Md5:    46db3d04b5f922ef10c7780ec248bc65
Sha1:   4f91f2d29793fcef745bd374ac356820ae90f483
Sha256: 03e65900190b99ade38d531d600fccdcac1cfb316634261121a0766783708bdd
                                        
                                            GET /wp-content/plugins/wp_logooos_plugin/js/helper-plugins/jquery.mousewheel.min.js?ver=4.9.5 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 20:54:00 GMT
Etag: W/"5a397c68-57c"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   736
Md5:    ce1578070f17458b623ab804bdc6bcdb
Sha1:   7f1037db41997afa0d98e5d60f3407d19491441c
Sha256: 95aa1f17438327bc914f7060302bd7c4aa6b805ab1f3f060eda9b27958ecf485
                                        
                                            GET /wp-content/plugins/wp_logooos_plugin/js/helper-plugins/jquery.touchSwipe.min.js?ver=4.9.5 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 20:54:00 GMT
Etag: W/"5a397c68-10e5"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   1981
Md5:    6b002c040e592066901fe54fd7dce290
Sha1:   1ad2e75814b1e52ab9a215c83ec1688b5c334873
Sha256: 2a85b6238b92cc711d8ff47fb1ec92e67bc0f962de3f570e7776cc1706ef5a3b
                                        
                                            GET /wp-content/plugins/wp_logooos_plugin/js/helper-plugins/jquery.ba-throttle-debounce.min.js?ver=4.9.5 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Content-Length: 739
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 20:54:00 GMT
Etag: "5a397c68-2e3"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII C program text, with very long lines, with CRLF line terminators
Size:   739
Md5:    3063b47a3871d8744a27aac6331b9904
Sha1:   2f33a1405372bab3bdd20a15695aa8481e8d364c
Sha256: 110973afe37ac008e0b5da625081cbdbe0da67ee31159d507bdd3f836c570b1e
                                        
                                            GET /wp-content/plugins/wp_logooos_plugin/js/helper-plugins/jquery.transit.min.js?ver=4.9.5 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 20:54:00 GMT
Etag: W/"5a397c68-1bac"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   2802
Md5:    86015a5e5a0670a7fc794ca9608b0996
Sha1:   9ed0f315da752fdf645f814a73227cd9a1b1ac27
Sha256: be7b19abd3f917db3cbddc3d08d98104ed933653163daab44f56eb8e5c694279
                                        
                                            GET /wp-content/plugins/wp_logooos_plugin/js/logos.js?ver=4.9.5 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 20:36:21 GMT
Etag: W/"5a397845-32b7"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   2900
Md5:    642870e42d048ec37a1b2c50aeb50272
Sha1:   a91dc838fcd9c644e2df0ccc12ca27bbf61a5fa0
Sha256: 7e68584520a1922a3474ae28919d01ae0635c240e8351be961ed9ac77aaf0af3
                                        
                                            GET /wp-content/plugins/chart-plugin/public/assets/js/excanvas.js?ver=1.7.4 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 20:54:28 GMT
Etag: W/"5a397c84-a109"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   14402
Md5:    aa7479b0232859013b0d14ad262092c8
Sha1:   52459763b26154980cc81dada431b0999507e4a7
Sha256: dc82219a37d121debff7d279cbf25758e392c64a08cbc6a1902797c528206021
                                        
                                            GET /wp-content/plugins/chart-plugin/public/assets/js/legend.js?ver=1.7.4 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 20:54:28 GMT
Etag: W/"5a397c84-745"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   678
Md5:    739d7fcdd5fadb6d8ae4ee6e2e9c266b
Sha1:   eab2889d2482b0c955e406950ad615d4d6138068
Sha256: 488a3829a9be440ab72260830a0bcbf3aed7777dd25d66e5c3bce0ea76425e88
                                        
                                            GET /wp-content/plugins/wp_logooos_plugin/js/jquery.carouFredSel-6.2.1.js?ver=4.9.5 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 20:36:21 GMT
Etag: W/"5a397845-163d2"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   23948
Md5:    7aa28a7804a7758335fab6a9b55df227
Sha1:   485352dd83b16de83fcf61bd3288755b3cc0ea06
Sha256: 56b4325ae47ce2e4a1ad9406cdf2a82ae51a8bcea61402d6142517bc06d6db98
                                        
                                            GET /wp-content/plugins/chart-plugin/public/assets/js/events.min.js?ver=1.7.4 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 20:54:28 GMT
Etag: W/"5a397c84-b57"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   688
Md5:    1cc68a40ef5ae93eb832e48cdf6c5736
Sha1:   d548e42a340a93ef630ab3d423895193b981c432
Sha256: 7289031897309f82705be8ccf2191803877f09e65c41088a2ae568ebb00f6e1f
                                        
                                            GET /wp-content/plugins/chart-plugin/public/assets/js/mutate.min.js?ver=1.7.4 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 20:54:28 GMT
Etag: W/"5a397c84-3f6"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   535
Md5:    d0ebcd0edf6461652e8733bead363973
Sha1:   19191013909db7e4bde1de38225a302228dee353
Sha256: c647fd2965b3ff658318446563ae8d8ccb4f08d8f4c71cebb7771e528b8712ac
                                        
                                            GET /wp-content/plugins/chart-plugin/public/assets/js/chartjs_new.js?ver=1.7.4 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 20:54:28 GMT
Etag: W/"5a397c84-1aa37"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   30503
Md5:    39366e511bcd4a7c0bbd1f8f5fb875db
Sha1:   c511d2cf90cd9c366fe5e62986066ff98e3dfeb2
Sha256: 4bb1356bbe2377540e95925de529a3f260552adeeb49030b3ea8f82f2e01b50f
                                        
                                            GET /wp-content/themes/smarsh/js/jquery.theme.js?ver=4.9.5 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Fri, 26 Jan 2018 23:21:36 GMT
Etag: W/"5a6bb800-4f5"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   625
Md5:    ad58b7cc88b8c139bed2631b5b8f216b
Sha1:   324ecdc4c31706ec5ceab1d759f76be09c74dc28
Sha256: efba1d6f7d58853ba774b99d54868ae34c2043d880eeb986e708d12f16b9319a
                                        
                                            GET /wp-content/plugins/chart-plugin/public/assets/js/public.js?ver=1.7.4 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 20:54:28 GMT
Etag: W/"5a397c84-2859"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   2763
Md5:    3f01afb7281062f1feb11b8b9d389801
Sha1:   8d447464ec60e2a51c5fa6070edc9beeb568f16f
Sha256: 95fdf3a73214f02105652793d9100e0fb6cdf99d6d460abe01e2cd1cba03fed5
                                        
                                            GET /wp-content/themes/enfold/js/avia-compat.js?ver=4.2.2 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Fri, 26 Jan 2018 01:47:19 GMT
Etag: W/"5a6a88a7-83a"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   993
Md5:    ff9359cccd58921de1eb8ecb6132522b
Sha1:   e001d9271230fa595e8caecbaea4cb1cfa55ded2
Sha256: b8aab5f70080087fb5bb739500703fcdacec9bb669168778e9f051f79ebf6ec1
                                        
                                            GET /wp-includes/js/mediaelement/mediaelement-migrate.min.js?ver=4.9.5 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Wed, 18 Oct 2017 02:26:48 GMT
Etag: W/"59e6bbe8-4a9"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   564
Md5:    662b340a69b47164745cb5b5b2f2ec63
Sha1:   08c62fc87d8bc845b76a3f90bd219e744556e619
Sha256: 1d42d172d1103d2a2e1a33981030458bcbd584b5a43f5cff50564eafcd13079e
                                        
                                            GET /wp-content/plugins/chart-plugin/public/assets/css/notie.css HTTP/1.1 
Host: www.smarsh.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.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Content-Length: 100
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 20:54:28 GMT
Etag: "5a397c84-64"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text
Size:   100
Md5:    7ccafde36c549d80f5b9da7e38db31a8
Sha1:   743361082463e550e204b44976c9994911ba6f94
Sha256: ed0ff3a92a3f75925193d6388e5a52c3483a9022999467209e3462aeb4f06328
                                        
                                            GET /wp-includes/js/wp-emoji-release.min.js?ver=4.9.5 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 23 Jan 2018 11:51:41 GMT
Etag: W/"5a6721cd-2dc9"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   4735
Md5:    b7786b42bc921b5950b4c8001411ff1b
Sha1:   37fd2f8680bcd360eca92ffe36b90e9eb148146e
Sha256: 0ac67b2f8c24b36ab22bc8b08c911c9acadf16182b277d68da2f4dbe77d7991b
                                        
                                            GET /wp-content/themes/enfold/config-layerslider/LayerSlider/static/layerslider/js/layerslider.transitions.js?ver=6.6.7 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Fri, 26 Jan 2018 01:47:19 GMT
Etag: W/"5a6a88a7-5d17"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   4279
Md5:    f6a254ac68f8f256d3541ae9c6e6a75f
Sha1:   432ddee3d9e5e75fb0ea7e4aaacafffcecc1215d
Sha256: b23961364a44bd090daa5120fc0169e7c3a8d4fe829a3ea49aabd9d89db51eb6
                                        
                                            GET /wp-content/plugins/gravityforms/css/formreset.min.css?ver=2.2.5 HTTP/1.1 
Host: www.smarsh.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.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 20:35:51 GMT
Etag: W/"5a397827-f00"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   426
Md5:    e1661affaf3d1161e13bfac8e3b7caf4
Sha1:   58e8902d3fb9fba08bbb054897cb42fa13849110
Sha256: 5f21c877f75160564a9784c261bd6c4ff596ea768692cfaaecbc97443dae2bca
                                        
                                            GET /wp-content/themes/enfold/config-layerslider/LayerSlider/static/layerslider/js/greensock.js?ver=1.19.0 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Fri, 26 Jan 2018 01:47:19 GMT
Etag: W/"5a6a88a7-1cb35"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   46012
Md5:    44b9c2eb229e9db5a781a5ee1b8ca27f
Sha1:   784899a6e6fb49187189432c4f681998524091d9
Sha256: 771eccb26d5466e7f68f4027accc64635143f46bdf7a939a7527696417939b57
                                        
                                            GET /wp-content/plugins/gravityforms/css/formsmain.min.css?ver=2.2.5 HTTP/1.1 
Host: www.smarsh.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.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 20:35:51 GMT
Etag: W/"5a397827-10bdd"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   13872
Md5:    99bccc074fcd85089a5bf4f374c1224f
Sha1:   6791d76feb5628959270fb058ee8257884ae5ef1
Sha256: 3a7f4a645a3d33bdfe4f36b6662d5f39e27766a783fcea484f3d84f28c7dc6f1
                                        
                                            GET /wp-includes/js/mediaelement/mediaelement-and-player.min.js?ver=4.2.6-78496d1 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Mon, 16 Oct 2017 18:07:52 GMT
Etag: W/"59e4f578-2638f"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   46223
Md5:    eb772c5311f303fe6ced7016170a6612
Sha1:   d656d20e61bca57fcdc1079df97fffd69bf5015e
Sha256: fc3fefc57df45e132448c9d03c4a5d3ab5a192b30b38b9ca5a59d31ef637c0a9
                                        
                                            GET /wp-content/themes/enfold/config-layerslider/LayerSlider/static/layerslider/js/layerslider.kreaturamedia.jquery.js?ver=6.6.7 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:24 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Fri, 26 Jan 2018 01:47:19 GMT
Etag: W/"5a6a88a7-1c643"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   50254
Md5:    b9a19fcdd6c8ed4b0b1488e8a4c0a1d2
Sha1:   3bf75825f4f73b009aa3faa95cbfc3a53a2cd50e
Sha256: b9b3ce6fef85ae6bab2c54b5ab64688d456c62d457fdebaba7147e647bed137e
                                        
                                            GET /wp-content/plugins/gravityforms/css/readyclass.min.css?ver=2.2.5 HTTP/1.1 
Host: www.smarsh.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.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:25 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 20:35:51 GMT
Etag: W/"5a397827-77ab"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   4232
Md5:    8ec07a0ed5fa0add4a85bf1cd1901807
Sha1:   cc042434f944cd2244ee14e2d9f3192b0c14c515
Sha256: 61d4492c8d29d45fa4d9bae1920e6d944f88f273fbc6a043f80836f96cdd270a
                                        
                                            GET /wp-content/plugins/gravityforms/css/browsers.min.css?ver=2.2.5 HTTP/1.1 
Host: www.smarsh.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.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:25 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 20:35:51 GMT
Etag: W/"5a397827-1c5e"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   1382
Md5:    1a4087e0d895ea8e9d5de6375c99614e
Sha1:   04a83e18d6c1a13909a321a99ec9bb21c836a207
Sha256: befb03145661da8911f265a6ee2a8edcb31eb2a6c1ca28c9061ece44ff60c3c4
                                        
                                            GET /wp-content/plugins/magic-tooltips-for-gravity-forms/assets/css/jquery.magic.min.css?ver=1.0.75.5 HTTP/1.1 
Host: www.smarsh.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.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:25 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Thu, 22 Feb 2018 20:11:12 GMT
Etag: W/"5a8f23e0-22e8"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   2491
Md5:    7fd30aa91c9a0f66def1d04a52004ce2
Sha1:   59a4bb99458446d81ef93639c5d800cf3e215222
Sha256: 8c0e46abd8d86c3db45ce44ad8566004ba328efd33434f6d9949ab401ebe2b91
                                        
                                            GET /wp-content/plugins/magic-tooltips-for-gravity-forms/assets/css/custom.css?ver=1.0.75.5 HTTP/1.1 
Host: www.smarsh.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.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:25 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Thu, 22 Feb 2018 20:11:12 GMT
Etag: W/"5a8f23e0-133d"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   2181
Md5:    b134b1cac943766854ca041cf2dd006e
Sha1:   08282b4ac1fe98db8369552748efb4aef3b65945
Sha256: 13607d585905b49542314fab6f6a526b2e55caa2a8727b6b22d1f85493a2ea58
                                        
                                            GET /wp-content/plugins/magic-tooltips-for-gravity-forms/assets/css/jquery.modal.css?ver=1.0.75.5 HTTP/1.1 
Host: www.smarsh.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.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:25 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Thu, 22 Feb 2018 20:11:12 GMT
Etag: W/"5a8f23e0-e31"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   1915
Md5:    ef5c23d71f33b43257c92066cb78b3df
Sha1:   71234f7a5c332682cecf3657ffe18b23ec476fad
Sha256: 31709313196dfd41e2f21f1e9139fbdf8ec4497dda71b1f2905db66d30d9fa96
                                        
                                            GET /wp-content/plugins/dk-pdf/assets/js/frontend.js?ver=1.9.3 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:25 GMT
Content-Length: 42
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 20:53:47 GMT
Etag: "5a397c5b-2a"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text
Size:   42
Md5:    41a6a9d24fde0f3c769bc824a96efe40
Sha1:   8e9678c351e8bbcabb8eaadf464d81febfed0918
Sha256: e16355e8227ed0b9a11065116c43b6ee9b9ec0fa9431086d77fb122510f0531b
                                        
                                            GET /wp-includes/js/jquery/ui/core.min.js?ver=1.11.4 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:25 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Thu, 03 Nov 2016 05:40:34 GMT
Etag: W/"581acdd2-fa0"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   1928
Md5:    c40ad6a990bce74a3ef62c99e6c23d0f
Sha1:   94b3115bb2c7ede039a0970eafefe0e8d66f8b63
Sha256: 72201b5ed1272a96e4dc7e9f3f53995f785f9824a159d06289b006e5211291fd
                                        
                                            GET /wp-includes/js/mediaelement/wp-mediaelement.min.js?ver=4.9.5 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:25 GMT
Content-Length: 914
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Wed, 24 Jan 2018 01:53:38 GMT
Etag: "5a67e722-392"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text, with very long lines, with no line terminators
Size:   914
Md5:    5d06470c0ac27ec77a1a6352f0558e35
Sha1:   d95d7fa683569f9d16bb64c76e2bb72abbb44d87
Sha256: 632af363989d420500a3fc1546178648f5aaa4f9aabb98666e62c3035fa423d1
                                        
                                            GET /wp-includes/js/comment-reply.min.js?ver=4.9.5 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:25 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Wed, 18 Nov 2015 19:15:28 GMT
Etag: W/"564cce50-436"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   597
Md5:    3f2a65ed29ffbf10694f6d44a1b87ca8
Sha1:   eeeaa4919b6dca1fa1ebe025d682a084662acb75
Sha256: ca1e401ab4f9fb86ad3ae9e2bb87e89b88efcf2fc3ecaf635bb455abdae49593
                                        
                                            GET /wp-includes/js/wp-embed.min.js?ver=4.9.5 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:25 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Wed, 23 Nov 2016 13:38:33 GMT
Etag: W/"58359bd9-576"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   765
Md5:    36d31e5e90ecad1726b083b201f01ac2
Sha1:   a932a9781ee6d270e4505dc5ed28e3108f9ee851
Sha256: c141ad9f1aa165b8ed384d8a8b755e763ea6b1696163e405d717af7ba2783f80
                                        
                                            GET /wp-content/themes/enfold/js/avia.js?ver=4.2.2 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:25 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Fri, 26 Jan 2018 01:47:19 GMT
Etag: W/"5a6a88a7-21a1d"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   44976
Md5:    27e78cf7171e82268092ca16d5f2e766
Sha1:   83e90bfd604c94e5cbdf92c787760d9a87da41a1
Sha256: 1a80092f88c504afdc4497643bf32ed5c9761f20d88a2298d5977455cafcfd33
                                        
                                            GET /wp-content/themes/enfold/js/shortcodes.js?ver=4.2.2 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:25 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Fri, 26 Jan 2018 01:47:19 GMT
Etag: W/"5a6a88a7-27772"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   46988
Md5:    0728cfac0e8ccb187bc4c43e014b3892
Sha1:   374a0db41edf5b1359b475f58acee1d594c97bbd
Sha256: 05f3e4e124a4a8a0e115b699205fe2bfb0d45659547ca4116953e35bd8aeb248
                                        
                                            GET /wp-content/plugins/gravityforms/js/jquery.json.min.js?ver=2.2.5 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:25 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 20:35:51 GMT
Etag: W/"5a397827-738"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   962
Md5:    575eefa8f2b4c01282cf3ec1570fe10c
Sha1:   a7eb8e6d0c37115675ce7945c7d4008ae70e299d
Sha256: 3cbe0545e67ee101ede2e0ef4a9eca1a8fc1026462ba05e2e52813b0b798273f
                                        
                                            GET /wp-content/plugins/gravityforms/js/gravityforms.min.js?ver=2.2.5 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:25 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 20:35:51 GMT
Etag: W/"5a397827-67cf"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   9549
Md5:    42fdc6d1df18e893c2344c7eb5bdbaa5
Sha1:   38efc1c411223e6511e585ab3b8002ad7ad8f3a9
Sha256: e082eb1e144b8f838b823b4dd213a48f3f2edc09560233955766471c6a3bdaff
                                        
                                            GET /wp-content/plugins/gravityforms/js/conditional_logic.min.js?ver=2.2.5 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:25 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 20:35:51 GMT
Etag: W/"5a397827-194f"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   2537
Md5:    32a0c911db0378c4e3cb1248128e7aac
Sha1:   11d66ce1c29b47235231c02d728ab3e0a0a0ad0e
Sha256: fef48764003d3cd42fbe107f37befa5dda5bfcee805df1e13032d581ec0f5096
                                        
                                            GET /wp-content/plugins/gravityforms/js/jquery.maskedinput.min.js?ver=2.2.5 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:25 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 20:36:21 GMT
Etag: W/"5a397845-10db"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   2052
Md5:    d9b336d542d01df45acc4c90194dec55
Sha1:   62d0ed707c0831236bfca90049916be88337856b
Sha256: ad6d2619c0ba25aac31344a0a9e000e3cdf9fc33d6fb27d1c619b1a94ffca23e
                                        
                                            GET /wp-content/plugins/gravityforms/js/placeholders.jquery.min.js?ver=2.2.5 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:25 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Tue, 19 Dec 2017 20:36:21 GMT
Etag: W/"5a397845-121f"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   1860
Md5:    580e180efd131a3556655d325c0185fb
Sha1:   cd8cb0ba83531feef107cd61996ceb6fdf93e873
Sha256: 41c7f5203caeb6f43be5b586ce4933f6a9cb6510e11fb1b94be613fe0fda4d8c
                                        
                                            GET /wp-content/plugins/magic-tooltips-for-gravity-forms/assets/js/custom.js?ver=1.0.75.5 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:25 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Thu, 22 Feb 2018 20:11:12 GMT
Etag: W/"5a8f23e0-6de4"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   7791
Md5:    06c8182ab2bdb8944f8513874ae6fd95
Sha1:   625681f153a89482e83dcf512b3802c56a64702f
Sha256: bc1094b79b321a71a4fda7544cf0596e6125a5c5d9404222c34b3d567bb3dc6d
                                        
                                            GET /wp-content/plugins/magic-tooltips-for-gravity-forms/assets/js/jquery.modal.js?ver=1.0.75.5 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:25 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Thu, 22 Feb 2018 20:11:12 GMT
Etag: W/"5a8f23e0-1fa5"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   2659
Md5:    04cd37e15e35499196beda0b3689187d
Sha1:   f0021e65810df6a050e45fbad352a9435ba574b5
Sha256: ecd85e8cb3211c290148e43926fb83b671b8c85bba3e9f537ccdfbfc3c37ba50
                                        
                                            GET /wp-content/plugins/gwreloadform/scripts/gp-reload-form.js?ver=1.1.14 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: application/x-javascript
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:25 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Fri, 13 Oct 2017 16:49:00 GMT
Etag: W/"59e0ee7c-9c9"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   898
Md5:    716f5c367563915ce2115cca85bd55dd
Sha1:   f4acda96bc92586099242ac7f1e1815707cb6069
Sha256: 3a8fa4f9fc19417e8b0b3c2b41f072e1fd939134554567a080971517b4b22942
                                        
                                            GET /wp-content/themes/enfold/style.css HTTP/1.1 
Host: www.smarsh.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.smarsh.com/wp-content/themes/smarsh/style.css?ver=4.2.2

                                         
                                         35.185.32.196
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Sat, 26 May 2018 00:27:25 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Last-Modified: Fri, 26 Jan 2018 01:47:19 GMT
Etag: W/"5a6a88a7-4a4"
X-Type: static/known
Cache-Control: public, max-age=2592000
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Content-Encoding: gzip


--- Additional Info ---
Magic:  gzip compressed data, from Unix
Size:   686
Md5:    0342d4878dbc79406e83bf2641e9dadb
Sha1:   c9a686d9c7366abea01420a02637ef706960d28a
Sha256: e82cd79f0f19a2128c5efa30747d8bf1904dece7b8eff29714411e592dc2f962
                                        
                                            GET /wp-content/plugins/magic-tooltips-for-gravity-forms/assets/js/jquery.magic.js?ver=1.0.75.5 HTTP/1.1 
Host: www.smarsh.com
                                        
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13
Accept: */*
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 115
Connection: keep-alive
Referer: https://www.smarsh.com/

                                         
                                         35.185.32.196
HTTP/1.1 200 OK