Overview

URL eicar.com
IP89.238.73.97
ASNmanitu GmbH
Location Germany
Report completed2022-09-28 12:24:22 UTC
StatusLoading report..
urlquery Alerts No alerts detected


Settings

UserAgentMozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Referer


Intrusion Detection Systems

Suricata /w Emerging Threats Pro  No alerts detected


Blocklists

OpenPhish  No alerts detected
PhishTank  No alerts detected
Fortinet's Web Filter  No alerts detected
mnemonic secure dns  No alerts detected
Quad9 DNS  No alerts detected


Files

No files detected



Passive DNS (16)

Passive DNS Source Fully Qualifying Domain Name Rank First Seen Last Seen IP Comment
mnemonic passive DNS eicar.com (2) 0 2017-02-01 14:59:38 UTC 2022-09-23 14:03:14 UTC 89.238.73.97 Unknown ranking
mnemonic passive DNS firefox.settings.services.mozilla.com (2) 867 2020-05-28 17:26:30 UTC 2022-09-28 11:00:28 UTC 143.204.55.35
mnemonic passive DNS content-signature-2.cdn.mozilla.net (1) 1152 2020-11-03 12:26:46 UTC 2022-09-28 05:13:47 UTC 143.204.55.35
mnemonic passive DNS ocsp.digicert.com (4) 86 2012-05-21 07:02:23 UTC 2022-09-28 08:57:43 UTC 93.184.220.29
mnemonic passive DNS img-getpocket.cdn.mozilla.net (7) 1631 2017-09-01 03:40:57 UTC 2022-09-28 08:06:38 UTC 34.120.237.76
mnemonic passive DNS www.eicar.com (36) 0 2012-06-28 18:19:32 UTC 2022-09-21 08:55:42 UTC 89.238.73.97 Unknown ranking
mnemonic passive DNS ocsp.pki.goog (8) 175 2017-06-14 07:23:31 UTC 2022-09-28 04:36:20 UTC 142.250.74.3
mnemonic passive DNS widget.tagembed.com (1) 311560 2021-03-24 15:02:49 UTC 2022-09-28 10:19:58 UTC 172.67.155.186
mnemonic passive DNS contile.services.mozilla.com (1) 1114 2021-05-27 18:32:35 UTC 2022-09-28 04:36:06 UTC 34.117.237.239
mnemonic passive DNS r3.o.lencr.org (6) 344 2020-12-02 08:52:13 UTC 2022-09-28 04:36:09 UTC 23.36.76.226
mnemonic passive DNS ka-f.fontawesome.com (5) 3598 2019-12-17 06:36:13 UTC 2022-09-28 05:17:22 UTC 172.64.202.28
mnemonic passive DNS platform.linkedin.com (1) 3785 2014-10-23 11:50:28 UTC 2022-09-28 05:45:13 UTC 23.36.76.121
mnemonic passive DNS img.youtube.com (5) 3087 2012-05-30 07:03:49 UTC 2022-09-28 05:28:09 UTC 216.58.207.238
mnemonic passive DNS www.youtube.com (1) 90 2013-05-30 23:21:49 UTC 2022-09-28 04:37:55 UTC 216.58.207.238
mnemonic passive DNS kit.fontawesome.com (1) 1868 2019-03-29 02:12:52 UTC 2022-09-28 05:17:22 UTC 104.18.22.52
mnemonic passive DNS push.services.mozilla.com (1) 2140 2015-09-03 10:29:36 UTC 2022-09-28 05:02:28 UTC 35.162.217.251


Recent reports on same IP/ASN/Domain/Screenshot

Last 5 reports on IP: 89.238.73.97

Date UQ / IDS / BL URL IP
2022-11-25 16:15:20 +0000
0 - 0 - 1 www.eicar.com/download/eicar-com/?wpdmdl=8840 (...) 89.238.73.97
2022-10-24 16:23:46 +0000
0 - 0 - 2 secure.eicar.org/eicar.com.txt 89.238.73.97
2022-10-13 08:59:57 +0000
0 - 0 - 3 eicar.com/download/eicar_com.zip 89.238.73.97
2022-10-12 22:23:43 +0000
0 - 0 - 3 eicar.com/download/eicar_com.zip 89.238.73.97
2022-10-12 22:23:14 +0000
0 - 0 - 3 eicar.com/download/eicar_com.zip 89.238.73.97

Last 5 reports on ASN: manitu GmbH

Date UQ / IDS / BL URL IP
2022-11-25 16:15:20 +0000
0 - 0 - 1 www.eicar.com/download/eicar-com/?wpdmdl=8840 (...) 89.238.73.97
2022-11-24 10:31:24 +0000
0 - 0 - 1 ranbv.de/adserver/www/delivery/ck.php?oadest= (...) 217.11.48.129
2022-11-23 07:40:42 +0000
0 - 0 - 2 minislb.de/ 89.238.73.78
2022-11-07 17:12:56 +0000
2 - 0 - 0 ask.libreoffice.org/t/is-there-a-native-way-t (...) 89.238.68.222
2022-10-24 16:23:46 +0000
0 - 0 - 2 secure.eicar.org/eicar.com.txt 89.238.73.97

Last 5 reports on domain: eicar.com

Date UQ / IDS / BL URL IP
2022-11-25 16:15:20 +0000
0 - 0 - 1 www.eicar.com/download/eicar-com/?wpdmdl=8840 (...) 89.238.73.97
2022-10-13 08:59:57 +0000
0 - 0 - 3 eicar.com/download/eicar_com.zip 89.238.73.97
2022-10-12 22:23:43 +0000
0 - 0 - 3 eicar.com/download/eicar_com.zip 89.238.73.97
2022-10-12 22:23:14 +0000
0 - 0 - 3 eicar.com/download/eicar_com.zip 89.238.73.97
2022-09-28 12:24:22 +0000
0 - 0 - 0 eicar.com 89.238.73.97

No other reports with similar screenshot



JavaScript

Executed Scripts (26)


Executed Evals (2)

#1 JavaScript::Eval (size: 56004, repeated: 1) - SHA256: 24b3f93884571849279d8557b859cc08a08153b123cc4943b99a7913a739bc70

                                        var layerSliderTransitions = {
    t2d: [{
        name: "Sliding from right",
        rows: 1,
        cols: 1,
        tile: {
            delay: 0,
            sequence: "forward"
        },
        transition: {
            type: "slide",
            easing: "easeInOutQuad",
            duration: 1e3,
            direction: "left"
        }
    }, {
        name: "Sliding from left",
        rows: 1,
        cols: 1,
        tile: {
            delay: 0,
            sequence: "forward"
        },
        transition: {
            type: "slide",
            easing: "easeInOutQuad",
            duration: 1e3,
            direction: "right"
        }
    }, {
        name: "Sliding from bottom",
        rows: 1,
        cols: 1,
        tile: {
            delay: 0,
            sequence: "forward"
        },
        transition: {
            type: "slide",
            easing: "easeInOutQuad",
            duration: 1e3,
            direction: "top"
        }
    }, {
        name: "Sliding from top",
        rows: 1,
        cols: 1,
        tile: {
            delay: 0,
            sequence: "forward"
        },
        transition: {
            type: "slide",
            easing: "easeInOutQuad",
            duration: 1e3,
            direction: "bottom"
        }
    }, {
        name: "Crossfading",
        rows: 1,
        cols: 1,
        tile: {
            delay: 0,
            sequence: "forward"
        },
        transition: {
            type: "fade",
            easing: "easeInOutQuad",
            duration: 1e3,
            direction: "left"
        }
    }, {
        name: "Fading tiles forward",
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 30,
            sequence: "forward"
        },
        transition: {
            type: "fade",
            easing: "easeOutQuart",
            duration: 1e3,
            direction: "left"
        }
    }, {
        name: "Fading tiles reverse",
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 30,
            sequence: "reverse"
        },
        transition: {
            type: "fade",
            easing: "easeOutQuart",
            duration: 1e3,
            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: 1e3,
            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: 1e3,
            direction: "left"
        }
    }, {
        name: "Fading tiles (random)",
        rows: [2, 4],
        cols: [4, 7],
        tile: {
            delay: 30,
            sequence: "random"
        },
        transition: {
            type: "fade",
            easing: "easeOutQuart",
            duration: 1e3,
            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: .5
        }
    }, {
        name: "Carousel rows",
        rows: 4,
        cols: 1,
        tile: {
            delay: 50,
            sequence: "forward"
        },
        transition: {
            type: "mixed",
            easing: "easeInOutQuad",
            duration: 750,
            direction: "left",
            scale: .5
        }
    }, {
        name: "Carousel cols",
        rows: 1,
        cols: 4,
        tile: {
            delay: 50,
            sequence: "forward"
        },
        transition: {
            type: "mixed",
            easing: "easeInOutQuad",
            duration: 750,
            direction: "left",
            scale: .5
        }
    }, {
        name: "Carousel tiles horizontal",
        rows: 3,
        cols: 4,
        tile: {
            delay: 35,
            sequence: "forward"
        },
        transition: {
            type: "mixed",
            easing: "easeInOutQuad",
            duration: 750,
            direction: "left",
            scale: .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: .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: .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: .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: .5
        }
    }, {
        name: "Carousel mirror cols",
        rows: 1,
        cols: 4,
        tile: {
            delay: 50,
            sequence: "forward"
        },
        transition: {
            type: "mixed",
            easing: "easeInOutQuad",
            duration: 750,
            direction: "left",
            scale: .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: .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: .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: .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: .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: .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"
        }
    }, {
        name: "Random slices to left",
        rows: 10,
        cols: 1,
        tile: {
            delay: 10,
            sequence: "random"
        },
        transition: {
            duration: 1500,
            easing: "easeInOutQuart",
            type: "slide",
            direction: "left"
        }
    }, {
        name: "Random slices to right",
        rows: 10,
        cols: 1,
        tile: {
            delay: 10,
            sequence: "random"
        },
        transition: {
            duration: 1500,
            easing: "easeInOutQuart",
            type: "slide",
            direction: "right"
        }
    }, {
        name: "Random slices to bottom",
        rows: 1,
        cols: 15,
        tile: {
            delay: 10,
            sequence: "random"
        },
        transition: {
            duration: 1500,
            easing: "easeInOutQuart",
            type: "slide",
            direction: "bottom"
        }
    }, {
        name: "Random slices to top",
        rows: 1,
        cols: 15,
        tile: {
            delay: 10,
            sequence: "random"
        },
        transition: {
            duration: 1500,
            easing: "easeInOutQuart",
            type: "slide",
            direction: "top"
        }
    }, {
        name: "Top-scaling from left",
        rows: 25,
        cols: 1,
        tile: {
            delay: 0,
            sequence: "reverse"
        },
        transition: {
            type: "scale",
            easing: "easeInOutQuart",
            duration: 2e3,
            direction: "right"
        }
    }, {
        name: "Top-scaling from right",
        rows: 25,
        cols: 1,
        tile: {
            delay: 0,
            sequence: "reverse"
        },
        transition: {
            type: "scale",
            easing: "easeInOutQuart",
            duration: 2e3,
            direction: "left"
        }
    }, {
        name: "Top-scaling from center",
        rows: 25,
        cols: 1,
        tile: {
            delay: 0,
            sequence: "reverse"
        },
        transition: {
            type: "scale",
            easing: "easeInOutQuart",
            duration: 2e3,
            direction: "center"
        }
    }, {
        name: "Bottom-scaling from left",
        rows: 25,
        cols: 1,
        tile: {
            delay: 0,
            sequence: "forward"
        },
        transition: {
            type: "scale",
            easing: "easeInOutQuart",
            duration: 2e3,
            direction: "right"
        }
    }, {
        name: "Bottom-scaling from right",
        rows: 25,
        cols: 1,
        tile: {
            delay: 0,
            sequence: "forward"
        },
        transition: {
            type: "scale",
            easing: "easeInOutQuart",
            duration: 2e3,
            direction: "left"
        }
    }, {
        name: "Bottom-scaling from center",
        rows: 25,
        cols: 1,
        tile: {
            delay: 0,
            sequence: "forward"
        },
        transition: {
            type: "scale",
            easing: "easeInOutQuart",
            duration: 2e3,
            direction: "center"
        }
    }, {
        name: "Middle-scaling from left",
        rows: 25,
        cols: 1,
        tile: {
            delay: 0,
            sequence: "center"
        },
        transition: {
            type: "scale",
            easing: "easeInOutQuart",
            duration: 2e3,
            direction: "right"
        }
    }, {
        name: "Middle-scaling from right",
        rows: 25,
        cols: 1,
        tile: {
            delay: 0,
            sequence: "center"
        },
        transition: {
            type: "scale",
            easing: "easeInOutQuart",
            duration: 2e3,
            direction: "left"
        }
    }, {
        name: "Middle-scaling from center",
        rows: 25,
        cols: 1,
        tile: {
            delay: 0,
            sequence: "center"
        },
        transition: {
            type: "scale",
            easing: "easeInOutQuart",
            duration: 2e3,
            direction: "center"
        }
    }, {
        name: "Edge-scaling from left",
        rows: 25,
        cols: 1,
        tile: {
            delay: 0,
            sequence: "edge"
        },
        transition: {
            type: "scale",
            easing: "easeInOutQuart",
            duration: 2e3,
            direction: "right"
        }
    }, {
        name: "Edge-scaling from right",
        rows: 25,
        cols: 1,
        tile: {
            delay: 0,
            sequence: "edge"
        },
        transition: {
            type: "scale",
            easing: "easeInOutQuart",
            duration: 2e3,
            direction: "left"
        }
    }, {
        name: "Edge-scaling from center",
        rows: 25,
        cols: 1,
        tile: {
            delay: 0,
            sequence: "edge"
        },
        transition: {
            type: "scale",
            easing: "easeInOutQuart",
            duration: 2e3,
            direction: "center"
        }
    }, {
        name: "Left-scaling from top",
        rows: 1,
        cols: 25,
        tile: {
            delay: 0,
            sequence: "reverse"
        },
        transition: {
            type: "scale",
            easing: "easeInOutQuart",
            duration: 2e3,
            direction: "bottom"
        }
    }, {
        name: "Left-scaling from bottom",
        rows: 1,
        cols: 25,
        tile: {
            delay: 0,
            sequence: "reverse"
        },
        transition: {
            type: "scale",
            easing: "easeInOutQuart",
            duration: 2e3,
            direction: "top"
        }
    }, {
        name: "Left-scaling from middle",
        rows: 1,
        cols: 25,
        tile: {
            delay: 0,
            sequence: "reverse"
        },
        transition: {
            type: "scale",
            easing: "easeInOutQuart",
            duration: 2e3,
            direction: "middle"
        }
    }, {
        name: "Right-scaling from top",
        rows: 1,
        cols: 25,
        tile: {
            delay: 0,
            sequence: "forward"
        },
        transition: {
            type: "scale",
            easing: "easeInOutQuart",
            duration: 2e3,
            direction: "bottom"
        }
    }, {
        name: "Right-scaling from bottom",
        rows: 1,
        cols: 25,
        tile: {
            delay: 0,
            sequence: "forward"
        },
        transition: {
            type: "scale",
            easing: "easeInOutQuart",
            duration: 2e3,
            direction: "top"
        }
    }, {
        name: "Right-scaling from middle",
        rows: 1,
        cols: 25,
        tile: {
            delay: 0,
            sequence: "forward"
        },
        transition: {
            type: "scale",
            easing: "easeInOutQuart",
            duration: 2e3,
            direction: "middle"
        }
    }, {
        name: "Center-scaling from top",
        rows: 1,
        cols: 25,
        tile: {
            delay: 0,
            sequence: "center"
        },
        transition: {
            type: "scale",
            easing: "easeInOutQuart",
            duration: 2e3,
            direction: "bottom"
        }
    }, {
        name: "Center-scaling from bottom",
        rows: 1,
        cols: 25,
        tile: {
            delay: 0,
            sequence: "center"
        },
        transition: {
            type: "scale",
            easing: "easeInOutQuart",
            duration: 2e3,
            direction: "top"
        }
    }, {
        name: "Center-scaling from middle",
        rows: 1,
        cols: 25,
        tile: {
            delay: 0,
            sequence: "center"
        },
        transition: {
            type: "scale",
            easing: "easeInOutQuart",
            duration: 2e3,
            direction: "middle"
        }
    }, {
        name: "Edge-scaling from top",
        rows: 1,
        cols: 25,
        tile: {
            delay: 0,
            sequence: "edge"
        },
        transition: {
            type: "scale",
            easing: "easeInOutQuart",
            duration: 2e3,
            direction: "bottom"
        }
    }, {
        name: "Edge-scaling from bottom",
        rows: 1,
        cols: 25,
        tile: {
            delay: 0,
            sequence: "edge"
        },
        transition: {
            type: "scale",
            easing: "easeInOutQuart",
            duration: 2e3,
            direction: "top"
        }
    }, {
        name: "Edge-scaling from middle",
        rows: 1,
        cols: 25,
        tile: {
            delay: 0,
            sequence: "edge"
        },
        transition: {
            type: "scale",
            easing: "easeInOutQuart",
            duration: 2e3,
            direction: "middle"
        }
    }, {
        name: "Edge-scaling horizontal left to right",
        rows: 25,
        cols: 1,
        tile: {
            delay: 0,
            sequence: "mirror"
        },
        transition: {
            type: "scale",
            easing: "easeInOutQuart",
            duration: 2e3,
            direction: "left"
        }
    }, {
        name: "Edge-scaling horizontal right to left",
        rows: 25,
        cols: 1,
        tile: {
            delay: 0,
            sequence: "mirror"
        },
        transition: {
            type: "scale",
            easing: "easeInOutQuart",
            duration: 2e3,
            direction: "right"
        }
    }, {
        name: "Edge-scaling vertical top to bottom",
        rows: 1,
        cols: 25,
        tile: {
            delay: 0,
            sequence: "mirror"
        },
        transition: {
            type: "scale",
            easing: "easeInOutQuart",
            duration: 2e3,
            direction: "top"
        }
    }, {
        name: "Edge-scaling vertical bottom to top",
        rows: 1,
        cols: 25,
        tile: {
            delay: 0,
            sequence: "mirror"
        },
        transition: {
            type: "scale",
            easing: "easeInOutQuart",
            duration: 2e3,
            direction: "bottom"
        }
    }],
    t3d: [{
        name: "Spinning tile to right (180�)",
        rows: 1,
        cols: 1,
        tile: {
            delay: 75,
            sequence: "forward"
        },
        animation: {
            transition: {
                rotateY: 91
            },
            easing: "easeInQuart",
            duration: 1e3,
            direction: "horizontal"
        },
        after: {
            transition: {
                rotateY: 180
            },
            easing: "easeOutQuart",
            duration: 1e3,
            direction: "horizontal"
        }
    }, {
        name: "Spinning tile to left (180�)",
        rows: 1,
        cols: 1,
        tile: {
            delay: 75,
            sequence: "forward"
        },
        animation: {
            transition: {
                rotateY: -91
            },
            easing: "easeInQuart",
            duration: 1e3,
            direction: "horizontal"
        },
        after: {
            transition: {
                rotateY: -180
            },
            easing: "easeOutQuart",
            duration: 1e3,
            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: 1e3,
            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: 1e3,
            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: 1e3,
            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: 1e3,
            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: .95
            },
            duration: 450,
            easing: "easeInOutQuint"
        },
        animation: {
            transition: {
                rotateY: 180
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .95
            },
            duration: 450,
            easing: "easeInOutQuint"
        },
        animation: {
            transition: {
                rotateY: -180
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .95
            },
            duration: 450,
            easing: "easeInOutQuint"
        },
        animation: {
            transition: {
                rotateX: -180
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .95
            },
            duration: 450,
            easing: "easeInOutQuint"
        },
        animation: {
            transition: {
                rotateX: 180
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .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: .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: 1e3,
            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: 1e3,
            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: 2e3,
            direction: "vertical"
        }
    }, {
        name: "Scaling and spinning rows to right (180�)",
        rows: [5, 9],
        cols: 1,
        tile: {
            delay: 55,
            sequence: "forward"
        },
        before: {
            transition: {
                scale3d: .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: .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: .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: .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: .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: .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: 1e3,
            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: 1e3,
            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: 2e3,
            direction: "horizontal"
        }
    }, {
        name: "Scaling and spinning columns to right (180�)",
        rows: 1,
        cols: [7, 11],
        tile: {
            delay: 55,
            sequence: "forward"
        },
        before: {
            transition: {
                scale3d: .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: .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: .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: .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: .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: .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: .85,
                rotateX: -30
            },
            duration: 600,
            easing: "easeOutQuart"
        },
        animation: {
            transition: {
                rotateX: -30,
                rotateY: 180
            },
            easing: "easeInOutQuart",
            duration: 1e3,
            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: .85,
                rotateX: -30
            },
            duration: 600,
            easing: "easeOutQuart"
        },
        animation: {
            transition: {
                rotateX: 30,
                rotateY: -180
            },
            easing: "easeInOutQuart",
            duration: 1e3,
            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: .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: .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: .85
            },
            duration: 450,
            easing: "easeInOutQuint"
        },
        animation: {
            transition: {
                rotateY: 90
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .85
            },
            duration: 450,
            easing: "easeInOutQuint"
        },
        animation: {
            transition: {
                rotateY: -90
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .85
            },
            duration: 450,
            easing: "easeInOutQuint"
        },
        animation: {
            transition: {
                rotateX: -90
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .85
            },
            duration: 450,
            easing: "easeInOutQuint"
        },
        animation: {
            transition: {
                rotateX: 90
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .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: .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: .85
            },
            duration: 600,
            easing: "easeOutBack"
        },
        animation: {
            transition: {
                rotateY: 87
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .85
            },
            duration: 600,
            easing: "easeOutBack"
        },
        animation: {
            transition: {
                rotateY: -90
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .85
            },
            duration: 600,
            easing: "easeOutBack"
        },
        animation: {
            transition: {
                rotateX: -90
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .85
            },
            duration: 600,
            easing: "easeOutBack"
        },
        animation: {
            transition: {
                rotateX: 90
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .85
            },
            duration: 600,
            easing: "easeOutBack"
        },
        animation: {
            transition: {
                rotateY: 90
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .85
            },
            duration: 600,
            easing: "easeOutBack"
        },
        animation: {
            transition: {
                rotateX: -90
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .85,
                rotateY: 45
            },
            easing: "easeInOutQuint",
            duration: 1e3,
            direction: "horizontal"
        },
        after: {
            transition: {
                rotateY: 90
            },
            easing: "easeInOutQuint",
            duration: 1e3
        }
    }, {
        name: "Scaling and horizontal turning drunk rows to left (90�)",
        rows: [7, 11],
        cols: 1,
        tile: {
            delay: 75,
            sequence: "reverse"
        },
        animation: {
            transition: {
                scale3d: .85,
                rotateY: -45
            },
            easing: "easeInOutQuint",
            duration: 1e3,
            direction: "horizontal"
        },
        after: {
            transition: {
                rotateY: -90
            },
            easing: "easeInOutQuint",
            duration: 1e3
        }
    }, {
        name: "Turning columns to bottom (90�)",
        rows: 1,
        cols: [5, 9],
        tile: {
            delay: 75,
            sequence: "forward"
        },
        animation: {
            transition: {
                rotateX: -90
            },
            easing: "easeInOutQuart",
            duration: 1e3,
            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: 1e3,
            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: 1e3,
            direction: "vertical"
        }
    }, {
        name: "Scaling and turning columns to bottom (90�)",
        rows: 1,
        cols: [7, 11],
        tile: {
            delay: 75,
            sequence: "forward"
        },
        before: {
            transition: {
                scale3d: .85
            },
            duration: 600,
            easing: "easeOutBack"
        },
        animation: {
            transition: {
                rotateX: -90
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .85
            },
            duration: 600,
            easing: "easeOutBack"
        },
        animation: {
            transition: {
                rotateX: 90
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .85
            },
            duration: 600,
            easing: "easeOutBack"
        },
        animation: {
            transition: {
                rotateY: 90
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .85
            },
            duration: 600,
            easing: "easeOutBack"
        },
        animation: {
            transition: {
                rotateY: -90
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .85
            },
            duration: 600,
            easing: "easeOutBack"
        },
        animation: {
            transition: {
                rotateY: 90
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .85
            },
            duration: 600,
            easing: "easeOutBack"
        },
        animation: {
            transition: {
                rotateX: -90
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .85,
                rotateX: 45
            },
            easing: "easeInOutQuint",
            duration: 1e3,
            direction: "vertical"
        },
        after: {
            transition: {
                rotateX: 90
            },
            easing: "easeInOutQuint",
            duration: 1e3
        }
    }, {
        name: "Scaling and vertical turning drunk columns to left (90�)",
        rows: 1,
        cols: [7, 11],
        tile: {
            delay: 75,
            sequence: "reverse"
        },
        animation: {
            transition: {
                scale3d: .85,
                rotateX: -45
            },
            easing: "easeInOutQuint",
            duration: 1e3,
            direction: "vertical"
        },
        after: {
            transition: {
                rotateX: -90
            },
            easing: "easeInOutQuint",
            duration: 1e3
        }
    }, {
        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: .85
            },
            duration: 450,
            easing: "easeInOutQuint"
        },
        animation: {
            transition: {
                rotateY: 180
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .85
            },
            duration: 450,
            easing: "easeInOutQuint"
        },
        animation: {
            transition: {
                rotateY: -180
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .85
            },
            duration: 450,
            easing: "easeInOutQuint"
        },
        animation: {
            transition: {
                rotateX: -180
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .85
            },
            duration: 450,
            easing: "easeInOutQuint"
        },
        animation: {
            transition: {
                rotateX: 180
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .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: .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: .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: .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: .85
            },
            duration: 600,
            easing: "easeOutBack"
        },
        animation: {
            transition: {
                rotateX: -180
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .85
            },
            duration: 600,
            easing: "easeOutBack"
        },
        animation: {
            transition: {
                rotateX: 180
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .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: .85
            },
            duration: 600,
            easing: "easeOutBack"
        },
        animation: {
            transition: {
                rotateX: -180
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .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: .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: .85
            },
            duration: 600,
            easing: "easeOutBack"
        },
        animation: {
            transition: {
                rotateY: 180
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .85
            },
            duration: 600,
            easing: "easeOutBack"
        },
        animation: {
            transition: {
                rotateY: -180
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .85
            },
            duration: 600,
            easing: "easeOutBack"
        },
        animation: {
            transition: {
                rotateY: 180
            },
            easing: "easeInOutBack",
            duration: 1e3,
            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: .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: .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: .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: .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: .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: 240241, repeated: 1) - SHA256: fd26cfa78c8661bbd8b33cd5750cebb8eb9036fe756e18184b2707d1137f231f

                                        ! function(ee) {
    "use strict";
    window._layerSliders = {}, ee.fn.layerSlider = function(i, a, s, r) {
        i = i || {};
        var t, e = "1.8.0",
            o = ee.fn.jquery;
        if (window._layerSlider.checkVersions(e, o, e)) return (typeof i).match("object|undefined") ? this.each(function(e) {
            t = "LS" + Math.random().toString(36).substr(2, 9), ee(this).data("lsSliderUID") || (window._layerSliders[t] = new n(this, ee(this), i, t))
        }) : "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(e) {
            var t = window._layerSliders[ee(this).data("lsSliderUID")];
            t && t.api.methods(i, a, s, r), t = null
        });
        window._layerSlider.showNotice(this, "oldjquery", o, e)
    };
    var n = function(I, $, i, B) {
        $.data("lsSliderUID", B).attr("data-layerslider-uid", B);
        var Z = this,
            J = Z.gsap = window._layerSlider.GSAP || window;
        Z.defaults = {
            init: {
                lsDataArraySplitChar: "|",
                dataKey: "_LS",
                controls: ["#playmedia", "#pausemedia", "#unmute", "#unmutemedia", "#start", "#stop", "#prev", "#next", "#replay", "#reverse", "#reverse-replay", "#reversereplay"],
                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: !1,
                    pauseLayers: !1,
                    firstSlide: 1,
                    sliderFadeInDuration: 350,
                    cycles: -1,
                    forceCycles: !0,
                    twoWaySlideshow: !1,
                    shuffleSlideshow: !1,
                    forceLayersOutDuration: 750,
                    slideDuration: !1,
                    slideDurationWithoutLayers: 3e3,
                    slideTransitionDuration: !1,
                    slideTimeShift: 0,
                    skin: "v6",
                    skinsPath: "/layerslider/skins/",
                    globalBGColor: "transparent",
                    globalBGImage: !1,
                    globalBGRepeat: "no-repeat",
                    globalBGAttachment: "scroll",
                    globalBGSize: "auto",
                    globalBGPosition: "50% 50%",
                    marginTop: !1,
                    marginBottom: !1,
                    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",
                    rememberUnmuteState: !0,
                    parallaxCenterDegree: 40,
                    parallaxSensitivity: 10,
                    parallaxCenterLayers: "center",
                    parallaxScrollReverse: !1,
                    scrollCenterLayers: "center",
                    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,
                    refreshWaypoint: !0,
                    staticImage: ""
                }
            },
            slider: {
                errorText: "LayerSlider (UID: " + B + ") 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"],
                    parallaxpath: ["parallax", "path"],
                    parallaxdirection: ["parallax", "direction"],
                    parallaxduration: ["parallax", "duration"],
                    parallaxcount: ["parallax", "count"],
                    parallaxdelay: ["parallax", "startAt"],
                    parallaxstartat: ["parallax", "startAt"],
                    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) {
                    Z.defaults.slide.options.plugins || (Z.defaults.slide.options.plugins = {}), Z.defaults.slide.options.plugins[e] = t
                }
            },
            layer: {
                keys: {
                    keyframe: ["is"],
                    responsive: ["is"],
                    position: ["settings"],
                    static: ["settings"],
                    minresponsiveratio: ["settings"],
                    maxresponsiveratio: ["settings"],
                    minfontsize: ["styleSettings"],
                    minmobilefontsize: ["styleSettings"],
                    overlay: ["styleSettings"],
                    pointerevents: ["styleSettings"],
                    autoplay: ["mediaSettings"],
                    controls: ["mediaSettings"],
                    showinfo: ["mediaSettings"],
                    fillmode: ["mediaSettings"],
                    thumbnail: ["poster", "mediaSettings"],
                    poster: ["mediaSettings"],
                    volume: ["mediaSettings"],
                    muted: ["mediaSettings"],
                    loopmedia: ["loop", "mediaSettings"],
                    backgroundvideo: ["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"],
                    transformmirrorin: ["mirror", "in"],
                    skipviewport: ["skipViewport", "settings"],
                    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"],
                    textcolorin: ["color", "textInNodesFrom"],
                    textoverflowin: ["overflow", "textInLayerStyle"],
                    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"],
                    texttransformmirrorin: ["mirror", "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"],
                    transformmirrorout: ["mirror", "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"],
                    textcolorout: ["color", "textOutNodesTo"],
                    texteaseout: ["ease", "textOutNodesTo"],
                    texteasingout: ["ease", "textOutNodesTo"],
                    texttransformoriginout: ["transformOrigin", "textOutShouldBeConverted"],
                    textoffsetxout: ["x", "textOutShouldBeConverted"],
                    textoffsetyout: ["y", "textOutShouldBeConverted"],
                    textoverflowout: ["overflow", "textOutLayerStyle"],
                    texttypeout: ["type", "textOut"],
                    textshiftout: ["shiftNodes", "textOut"],
                    textdelayout: ["startAt", "textOut"],
                    textstartatout: ["startAt", "textOut"],
                    textoutstartat: ["startAt", "textOut"],
                    textdurationout: ["duration", "textOut"],
                    texttransitionout: ["enabled", "textOut"],
                    texttransformmirrorout: ["mirror", "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"],
                    parallaxpath: ["path", "parallax"],
                    parallaxdirection: ["direction", "parallax"],
                    parallaxduration: ["duration", "parallax"],
                    parallaxcount: ["count", "parallax"],
                    parallaxdelay: ["startAt", "parallax"],
                    parallaxstartat: ["startAt", "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"],
                    scroll: ["enabled", "scroll"],
                    scrollduration: ["duration", "scroll"],
                    scrollcenter: ["center", "scroll"],
                    scrollopacity: ["opacity", "scroll"],
                    scrollopacitymin: ["opacitymin", "scroll"],
                    scrollopacitymax: ["opacitymax", "scroll"],
                    scrollopacityyoyo: ["opacityyoyo", "scroll"],
                    scrollopacityinvert: ["opacityinvert", "scroll"],
                    scrollrotate: ["rotation", "scroll"],
                    scrollrotatemin: ["rotationmin", "scroll"],
                    scrollrotatemax: ["rotationmax", "scroll"],
                    scrollrotateyoyo: ["rotationyoyo", "scroll"],
                    scrollrotatex: ["rotationX", "scroll"],
                    scrollrotatexmin: ["rotationXmin", "scroll"],
                    scrollrotatexmax: ["rotationXmax", "scroll"],
                    scrollrotatexyoyo: ["rotationXyoyo", "scroll"],
                    scrollrotatey: ["rotationY", "scroll"],
                    scrollrotateymin: ["rotationYmin", "scroll"],
                    scrollrotateymax: ["rotationYmax", "scroll"],
                    scrollrotateyyoyo: ["rotationYyoyo", "scroll"],
                    scrollrotation: ["rotation", "scroll"],
                    scrollrotationmin: ["rotationmin", "scroll"],
                    scrollrotationmax: ["rotationmax", "scroll"],
                    scrollrotationyoyo: ["rotationyoyo", "scroll"],
                    scrollrotationx: ["rotationX", "scroll"],
                    scrollrotationxmin: ["rotationXmin", "scroll"],
                    scrollrotationxmax: ["rotationXmax", "scroll"],
                    scrollrotationxyoyo: ["rotationXyoyo", "scroll"],
                    scrollrotationy: ["rotationY", "scroll"],
                    scrollrotationymin: ["rotationYmin", "scroll"],
                    scrollrotationymax: ["rotationYmax", "scroll"],
                    scrollrotationyyoyo: ["rotationYyoyo", "scroll"],
                    scrollscalex: ["scaleX", "scroll"],
                    scrollscalexmin: ["scaleXmin", "scroll"],
                    scrollscalexmax: ["scaleXmax", "scroll"],
                    scrollscalexyoyo: ["scaleXyoyo", "scroll"],
                    scrollscaley: ["scaleY", "scroll"],
                    scrollscaleymin: ["scaleYmin", "scroll"],
                    scrollscaleymax: ["scaleYmax", "scroll"],
                    scrollscaleyyoyo: ["scaleYyoyo", "scroll"],
                    scrollskewx: ["skewX", "scroll"],
                    scrollskewxmin: ["skewXmin", "scroll"],
                    scrollskewxmax: ["skewXmax", "scroll"],
                    scrollskewxyoyo: ["skewXyoyo", "scroll"],
                    scrollskewy: ["skewY", "scroll"],
                    scrollskewymin: ["skewYmin", "scroll"],
                    scrollskewymax: ["skewYmax", "scroll"],
                    scrollskewyyoyo: ["skewYyoyo", "scroll"],
                    scrolloffsetx: ["x", "scroll"],
                    scrolloffsetxmin: ["xmin", "scroll"],
                    scrolloffsetxmax: ["xmax", "scroll"],
                    scrolloffsetxyoyo: ["xyoyo", "scroll"],
                    scrolloffsetxresponsive: ["xresponsive", "scroll"],
                    scrolloffsety: ["y", "scroll"],
                    scrolloffsetymin: ["ymin", "scroll"],
                    scrolloffsetymax: ["ymax", "scroll"],
                    scrolloffsetyyoyo: ["yyoyo", "scroll"],
                    scrolloffsetyresponsive: ["yresponsive", "scroll"],
                    scrolltransformorigin: ["transformOrigin", "scrollShouldBeConverted"],
                    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"],
                    scrolltransformperspective: ["scroll", "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: {
                    slidestart: [0],
                    transitioninstart: [1],
                    transitioninend: [2],
                    textinstart: [3, [1, 2, 6, 7, 8]],
                    textinend: [4],
                    allinend: [5],
                    loopstart: [6, [1, 2, 3, 4, 5]],
                    loopend: [7],
                    autoparallaxstart: [6.5, [0, 1, 2, 3, 4, 5, 6, 7]],
                    autoparallaxend: [7.5],
                    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) {
                    t = {
                        is: {
                            slideBackground: !!e.is("img.ls-bg"),
                            backgroundVideo: !!e.is(".ls-bg-video"),
                            imageLayer: !!e.is("img.ls-layer"),
                            layerGroup: !!e.is(".ls-layer-group"),
                            insideLayerGroup: !!e.data("$layerGroup"),
                            mediaLayer: !1,
                            textLayer: !1,
                            responsive: !0,
                            onSlide: t
                        },
                        should: {},
                        elements: {},
                        settings: {
                            position: "relative",
                            slideIn: t,
                            slideOut: t
                        },
                        styleSettings: {
                            minfontsize: 0,
                            minmobilefontsize: 0
                        },
                        mediaSettings: {
                            fillmode: "cover",
                            backgroundVideo: !1
                        },
                        timeline: {
                            slidestart: 0,
                            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 = Z.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) : Z.debugMode && Z.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() {
                                        Z.transitions.layers.in.onStart(e)
                                    },
                                    onComplete: function() {
                                        Z.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
                                },
                                layerStyle: {},
                                split: "",
                                shiftNodes: .05,
                                startAt: "transitioninend",
                                duration: 1
                            }, out: {
                                enabled: !0,
                                layerFrom: {
                                    autoCSS: !1,
                                    immediateRender: !1,
                                    css: {}
                                },
                                layerTo: {
                                    autoCSS: !1,
                                    onStart: function() {
                                        Z.transitions.layers.out.onStart(e)
                                    },
                                    onComplete: function() {
                                        Z.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
                                },
                                layerStyle: {},
                                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
                            }, scroll: {
                                enabled: null,
                                xresponsive: !0,
                                yresponsive: !0,
                                shouldBeConverted: {
                                    transformOrigin: "50% 50% 0"
                                }
                            }, 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: t.is,
                        should: t.should,
                        elements: t.elements,
                        settings: t.settings,
                        styleSettings: t.styleSettings,
                        mediaSettings: t.mediaSettings,
                        mediaProperties: t.mediaProperties,
                        timeline: t.timeline,
                        in : t.transitionProperties.in,
                        inLayerFrom: t.transitionProperties.in.layerFrom,
                        inLayerFromCSS: t.transitionProperties.in.layerFrom.css,
                        inLayerStyleFrom: t.transitionProperties.in.layerStyleFrom,
                        inLayerStyleFromCSS: t.transitionProperties.in.layerStyleFrom.css,
                        inClipFrom: t.transitionProperties.in.clipFrom,
                        inClipFromCSS: t.transitionProperties.in.clipFrom.css,
                        inLayerTo: t.transitionProperties.in.layerTo,
                        inLayerToCSS: t.transitionProperties.in.layerTo.css,
                        inLayerStyleTo: t.transitionProperties.in.layerStyleTo,
                        inLayerStyleToCSS: t.transitionProperties.in.layerStyleTo.css,
                        inClipTo: t.transitionProperties.in.clipTo,
                        inClipToCSS: t.transitionProperties.in.clipTo.css,
                        inClipShouldBeConverted: t.transitionProperties.in.clipShouldBeConverted,
                        inLayerShouldBeConverted: t.transitionProperties.in.layerShouldBeConverted,
                        inLayerStyleShouldBeConvertedFrom: t.transitionProperties.in.layerStyleShouldBeConvertedFrom,
                        inLayerStyleShouldBeConvertedTo: t.transitionProperties.in.layerStyleShouldBeConvertedTo,
                        textIn: t.transitionProperties.textIn,
                        textInLayerStyle: t.transitionProperties.textIn.layerStyle,
                        textInNodesFrom: t.transitionProperties.textIn.nodesFrom,
                        textInNodesTo: t.transitionProperties.textIn.nodesTo,
                        textInNodesToCSS: t.transitionProperties.textIn.nodesTo.css,
                        textInShouldBeConverted: t.transitionProperties.textIn.shouldBeConverted,
                        out: t.transitionProperties.out,
                        outLayerFrom: t.transitionProperties.out.layerFrom,
                        outLayerFromCSS: t.transitionProperties.out.layerFrom.css,
                        outLayerStyleFrom: t.transitionProperties.out.layerStyleFrom,
                        outLayerStyleFromCSS: t.transitionProperties.out.layerStyleFrom.css,
                        outLayerTo: t.transitionProperties.out.layerTo,
                        outLayerToCSS: t.transitionProperties.out.layerTo.css,
                        outLayerStyleTo: t.transitionProperties.out.layerStyleTo,
                        outLayerStyleToCSS: t.transitionProperties.out.layerStyleTo.css,
                        outClipTo: t.transitionProperties.out.clipTo,
                        outClipToCSS: t.transitionProperties.out.clipTo.css,
                        outClipShouldBeConverted: t.transitionProperties.out.clipShouldBeConverted,
                        outLayerShouldBeConverted: t.transitionProperties.out.layerShouldBeConverted,
                        outLayerStyleShouldBeConvertedFrom: t.transitionProperties.out.layerStyleShouldBeConvertedFrom,
                        outLayerStyleShouldBeConvertedTo: t.transitionProperties.out.layerStyleShouldBeConvertedTo,
                        textOut: t.transitionProperties.textOut,
                        textOutLayerStyle: t.transitionProperties.textOut.layerStyle,
                        textOutNodesFrom: t.transitionProperties.textOut.nodesFrom,
                        textOutNodesTo: t.transitionProperties.textOut.nodesTo,
                        textOutShouldBeConverted: t.transitionProperties.textOut.shouldBeConverted,
                        loop: t.transitionProperties.loop,
                        loopFrom: t.transitionProperties.loop.from,
                        loopFromCSS: t.transitionProperties.loop.from.css,
                        loopTo: t.transitionProperties.loop.to,
                        loopToCSS: t.transitionProperties.loop.to.css,
                        loopClipTo: t.transitionProperties.loop.clipTo,
                        loopClipToCSS: t.transitionProperties.loop.clipTo.css,
                        loopClipShouldBeConverted: t.transitionProperties.loop.clipShouldBeConverted,
                        loopLayerShouldBeConverted: t.transitionProperties.loop.layerShouldBeConverted,
                        hover: t.transitionProperties.hover,
                        hoverFrom: t.transitionProperties.hover.from,
                        hoverFromCSS: t.transitionProperties.hover.from.css,
                        hoverTo: t.transitionProperties.hover.to,
                        hoverToCSS: t.transitionProperties.hover.to.css,
                        hoverShouldBeConverted: t.transitionProperties.hover.shouldBeConverted,
                        parallax: t.transitionProperties.parallax,
                        scroll: t.transitionProperties.scroll,
                        scrollShouldBeConverted: t.transitionProperties.scroll.shouldBeConverted,
                        kenBurns: t.transitionProperties.kenBurns,
                        clip: t.transitionProperties.clip,
                        filter: t.transitionProperties.filter,
                        transformPerspective: t.transitionProperties.transformPerspective,
                        init: t.transitionProperties.init,
                        reset: t.transitionProperties.reset
                    }
                }
            }
        }, Z.slides = {
            count: 0,
            first: {},
            prev: {},
            current: {},
            next: {},
            init: function() {
                if (!document.body.contains(I)) return !1;
                for (var e = $.find("> .ls-layer, > .ls-slide"), t = 0, i = Z.defaults.slide.keys, a = 0, s = e.length; a < s; a++) {
                    var r = ee(e[a]),
                        o = r[0].style,
                        n = ee.extend(!0, {}, Z.defaults.slide.options),
                        l = !1;
                    if (Z.slides.count++, r.removeClass("ls-layer").addClass("ls-slide").css({
                            width: Z.slider.initial.originalWidth,
                            height: Z.slider.initial.originalHeight
                        }).appendTo(Z.slider.$hiddenWrapper), r.data("ls"))
                        for (var d = r.data("ls").split(";"), c = 0; c < d.length; c++) {
                            var u, p, h = d[c].split(":");
                            h[0] = ee.trim(h[0].toLowerCase()), h[1] = ee.trim(h[1]), -1 == ["thumbnail"].indexOf(h[0]) && (h[1] = h[1].toLowerCase()), "" !== h[0] && (void 0 !== i[h[0]] ? (u = void 0 === i[h[0]][1] ? h[0] : i[h[0]][1], p = Z.functions.convert.properties(h[1]), -1 === u.toLowerCase().indexOf("duration") && -1 === u.toLowerCase().indexOf("delay") && "timeShift" != u || (p /= 1e3), n[i[h[0]][0]] || (n[i[h[0]][0]] = {}), n[i[h[0]][0]][u] = p) : n.data[h[0]] = h[1])
                        }
                    if (n.plugins && !ee.isEmptyObject(n.plugins))
                        for (var m in n.plugins)
                            if (r.data("ls-plugin-" + m)) {
                                var f, g = r.data("ls-plugin-" + m).toLowerCase().split(";"),
                                    y = {};
                                for (f in n.plugins[m]) y[f.toLowerCase()] = f;
                                for (var v = 0; v < g.length; v++) {
                                    var b, w = g[v].split(":");
                                    w[0] = ee.trim(w[0]), "" !== w[0] && (b = Z.functions.convert.properties(ee.trim(w[1])), -1 === w[0].indexOf("duration") && -1 === w[0].indexOf("delay") || (b /= 1e3), y[w[0]] ? n.plugins[m][y[w[0]]] = b : n.plugins[m][w[0]] = b)
                                }
                            } else delete n.plugins[m];
                    r.children("a.ls-link").length && (n.data.$link = r.children("a.ls-link").first().css({
                        zIndex: 5
                    }).attr("data-ls-slide-link", t + 1).appendTo(Z.slider.$layersWrapper), Z.layers.set.smartLinks(n.data.$link)), n.data.$backgroundVideo = r.children('[data-ls*="backgroundvideo"]').first(), n.data.$backgroundVideo.find("iframe, video, audio").length || (n.data.$backgroundVideo = ee()), n.data.$backgroundVideo.length && (null !== n.data.$backgroundVideo.attr("data-ls").split("backgroundvideo")[1].split(";")[0].match(/(true|enabled|on|1)/i) ? (n.data.$backgroundVideo.addClass("ls-bg-video").css({
                        width: "auto",
                        height: "auto"
                    }).children("video, audio, iframe").css({
                        width: "100%",
                        height: "100%"
                    }), n.data.$backgroundVideo.append(ee('<div class="ls-bg-video-overlay"></div>'))) : n.data.$backgroundVideo = !1);
                    for (var S = r.find("picture"), v = 0, x = S.length; v < x; v++) Z.layers.set.pictureElement(ee(S[v]));
                    r.find("> .ls-bg").length && (n.data.$background = r.find("> .ls-bg").first()), n.data.thumbnail || (r.find("> .ls-tn").length ? l = r.find("> .ls-tn").first() : r.find("> .ls-bg").length && (l = r.find("> .ls-bg").first()), l ? (n.data.thumbnail = Z.functions.getURL(l), n.data.tnAlt = Z.functions.getALT(l)) : n.data.thumbnail = Z.o.skinsPath + Z.o.skin + "/nothumb.png"), (n.data.customtransition2d || n.data.customtransition3d) && "undefined" == typeof layerSliderCustomTransitions && (delete n.data.customtransition2d, delete n.data.customtransition3d, Z.debugMode && Z.debug.add("warn", "sliderInit.customTransitions", t + 1)), "visible" === o.overflow && (n.data.overflow = "visible"), n.data.backgroundColor ? n.data.$background || n.data.$backgroundVideo && n.data.$backgroundVideo.length || (n.data.$background = ee("<img>").addClass("ls-bg").attr("src", "data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==").appendTo(r)) : n.data.backgroundColor = "" === r[0].style.backgroundColor ? "transparent" : r[0].style.backgroundColor, Z.slides[++t] = {}, Z.slides[t].data = ee.extend(!0, {}, Z.defaults.slide.options.data, n.data), Z.slides[t].parallax = n.parallax, Z.slides[t].scroll = n.scroll, Z.slides[t].kenBurns = n.kenBurns, Z.slides[t].filter = n.filter, Z.slides[t].index = t, Z.slides[t].$layers = ee(), Z.slides[t].plugins = n.plugins, Z.slider.thumbnails.push(n.data.thumbnail), Z.layers.init(r, t)
                }
                Z.debugMode && Z.debug.groupEnd("sliderInit.style")
            },
            set: {
                slideIndexes: function() {
                    var e = Z.slides;
                    e.prev.index = e.current.index, e.current.index = e.next.index, e.next.index = Z.slideshow.get.slideInSequence(Z.slideshow.direction), e.set.slidesData(), Z.slider.set.attributes()
                },
                nextSlideIndex: function(e) {
                    var t = Z.slides;
                    t.next.index = e, t.set.slidesData()
                },
                slidesData: function() {
                    var e = Z.slides;
                    e.prev = -1 !== e.prev.index ? ee.extend(!0, {}, e[e.prev.index]) : {}, e.current = -1 !== e.current.index ? ee.extend(!0, {}, e[e.current.index]) : {}, e.next = -1 !== e.next.index ? ee.extend(!0, {}, e[e.next.index]) : {}
                },
                firstSlide: function() {
                    var e, t = Z.slides;
                    t.first.index = "random" === Z.o.firstSlide ? Z.o.firstSlide : Math.max(Z.functions.convert.properties(Z.o.firstSlide, !0), 1), Z.o.shuffleSlideshow && 2 < Z.slides.count ? Z.o.twoWaySlideshow = !1 : Z.o.shuffleSlideshow = !1, t.first.index = "random" == t.first.index ? Math.floor(Math.random() * Z.slides.count + 1) : t.first.index, !document.location.hash || (e = Z.slides.deeplink(document.location.hash, !0)) && (Z.slides.first.index = e), t.first.index = t.first.index < 1 || t.first.index > Z.slides.count ? 1 : t.first.index, Z.o.shuffleSlideshow && "random" != Z.o.firstSlide && (t.first.index = Z.o.firstSlide), t[t.first.index] && t[t.first.index].data && (t.first.data = ee.extend(!0, {}, t[t.first.index].data)), Z.o.playByScroll && Z.slideshow.set.normalizedSequence(), Z.debugMode && Z.debug.options.firstSlide && (t.first.index = Z.debug.options.firstSlide)
                }
            },
            get: {
                deeplink: function(e) {
                    return e && Z.slides[e] && Z.slides[e].data && Z.slides[e].data.deeplink ? Z.slides[e].data.deeplink : null
                }
            },
            deeplink: function(e, t) {
                for (var i = !1, a = 1; a < Z.slides.count + 1; a++)
                    if (Z.slides[a].data.deeplink == e.substring(1)) {
                        if (i = a, t) return i;
                        Z.slideshow.changeTo(i, !0, !0)
                    }
                if (!i && t) return !1
            },
            slide: []
        }, Z.layers = {
            $all: ee(),
            getStyle: function(e, t) {
                return -1 != e.indexOf("em") ? e : (-1 != e.indexOf("%") ? parseFloat(e) * t : parseFloat(e) || 0).toString()
            },
            toNum: function(e, t) {
                return t = parseFloat(t), -1 != e.indexOf("em") ? parseFloat(e) * t : parseFloat(e)
            },
            init: function(e, t) {
                if (!document.body.contains(I)) return !1;
                for (var i, a = e.find(".ls-bg, .ls-l, .ls-layer, .ls-lg, .ls-layer-group"), s = 0, r = a.length; s < r; s++) {
                    var o = ee(a[s]),
                        n = o[0],
                        l = o.children();
                    if (o.data("slideIndex", t), o.hasClass("ls-l")) o.removeClass("ls-l").addClass("ls-layer");
                    else if (o.hasClass("ls-lg")) o.removeClass("ls-lg").addClass("ls-layer-group");
                    else if (!o.is(".ls-bg, .ls-layer, .ls-layer-group")) {
                        o.remove();
                        continue
                    }
                    o.is("a") && 1 === l.length && ((n = (o = o.children().first())[0]).setAttribute("data-ls", n.parentNode.getAttribute("data-ls")), n.parentNode.removeAttribute("data-ls"), o.parent().removeClass("ls-layer"), o.addClass("ls-layer")), o.is(".ls-layer-group") && o.children().data("$layerGroup", o), o.data(Z.defaults.init.dataKey, new Z.defaults.layer.options(o, t)), -1 !== o.attr("class").indexOf("ls-linkto-") && this.set.linkTo(o), o.parent().is("a") ? (i = o.parent(), this.set.smartLinks(i)) : i = o, i.attr("data-ls-actions") && this.set.actions(i, JSON.parse(i.attr("data-ls-actions")) || {}), Z.slides[t].$layers = Z.slides[t].$layers.add(i)
                }
            },
            set: {
                mirrorTransitions: function(e) {
                    return e = e.split(" ")
                },
                pictureElement: function(e) {
                    var t = e.find("source").last().attr("srcset").split(" ")[0] || "data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==",
                        i = e.find("img"),
                        a = i.length ? i : ee("<img>").attr("src", t),
                        s = a[0],
                        r = (e.attr("ls-data") || a.attr("ls-data"), e.attr("style") || !1),
                        i = s.currentSrc || s.src,
                        o = i.split(".").pop(),
                        t = (i.indexOf("webp"), a.attr("data-src") ? "data-" : ""),
                        s = "";
                    e.hasClass("ls-bg") ? s = "ls-bg" : e.hasClass("ls-tn") ? s = "ls-tn" : (e.hasClass("ls-l") || e.hasClass("ls-layer")) && (s = "ls-layer");
                    for (var n, l, d, c = e.find("source"), u = 0; u < c.length && (n = c[u], l = (n = ee(n)).attr("srcset"), d = n.attr("sizes"), l.split(" ")[0].split(".").pop() != o); u++);
                    a.removeAttr("width height sizes src srcset data-src data-srcset loading"), a.addClass(s).attr(t + "src", i).attr(t + "srcset", l).attr("sizes", d), r && a.attr("style", r), a.insertAfter(e), e.remove()
                },
                actions: function(t, i) {
                    var a = i.length;
                    for (let e = 0; e < a; e++) {
                        var s = i[e];
                        t.on(s.trigger, function() {
                            setTimeout(function(e) {
                                r(e)
                            }, s.delay || 0, s)
                        })
                    }
                    var r = function(s) {
                        let r = !1,
                            o = "";
                        switch (s.action) {
                            case "scrollBelowProject":
                            case "scrollToNextProject":
                            case "scrollToPrevProject":
                            case "scrollToElement":
                                let e, t = ee(".ls-wp-container:not(.ls-hidden"),
                                    i = ee([]);
                                if ("scrollBelowProject" === s.action) e = Z.slider.offsetTop + Z.slider.height + (s.offset || 0);
                                else if ("scrollToPrevProject" === s.action) 0 !== t.index($) ? (i = t.eq(t.index($) - 1), e = parseInt(i.offset().top) + (s.offset || 0)) : r = "Theres no previous project to scroll to.";
                                else if ("scrollToNextProject" === s.action) t.index($) < t.length - 1 ? (i = t.eq(t.index($) + 1), e = parseInt(i.offset().top) + (s.offset || 0)) : r = "Theres no next project to scroll to.";
                                else if ("scrollToElement" === s.action) {
                                    try {
                                        i = ee(s.selector.toString()).not(".ls-wp-container.ls-hidden")
                                    } catch (e) {
                                        o = e
                                    }
                                    i.size() ? e = parseInt(i.offset().top) + (s.offset || 0) : r = 'Couldnt find the scroll target element "' + s.selector + '". Please verify the selector youve entered.'
                                }
                                r || J.TweenMax.to("html, body", (s.duration || 1e3) / 1e3, {
                                    scrollTop: e,
                                    ease: Z.functions.convert.easing(s.easing)
                                });
                                break;
                            case "switchSlide":
                                Z.slideshow.changeTo(s.slide, !0, !0);
                                break;
                            case "nextSlide":
                            case "prevSlide":
                            case "stopSlideshow":
                            case "startSlideshow":
                                let a;
                                "nextSlide" === s.action && (a = "next"), "prevSlide" === s.action && (a = "prev"), "stopSlideshow" === s.action && (a = "stop"), "startSlideshow" === s.action && (a = "start"), Z.navigation[a]("clicked");
                                break;
                            case "replaySlide":
                                Z.api.methods("replay");
                                break;
                            case "reverseSlide":
                                Z.api.methods("reverse", s.replay);
                                break;
                            case "resetSlide":
                                Z.api.methods("resetSlide");
                                break;
                            case "pauseProject":
                                Z.api.methods("pauseSlider");
                                break;
                            case "resumeProject":
                                Z.api.methods("resumeSlider");
                                break;
                            case "toggleProject":
                                Z.api.methods("toggleSlider");
                                break;
                            case "playMedia":
                                Z.media.functions.playActiveMedia();
                                break;
                            case "pauseMedia":
                                Z.media.functions.pauseActiveMedia();
                                break;
                            case "unmuteMedia":
                                Z.media.unmute.multipleMediaElements();
                                break;
                            case "openPopup":
                                Z.actions.openPopup(s);
                                break;
                            case "launchPopups":
                                Z.actions.launchPopups();
                                break;
                            case "closePopup":
                                Z.api.methods("closePopup");
                                break;
                            case "closeAllPopups":
                                Z.api.methods("closeAllPopups");
                                break;
                            case "jsFunction":
                                try {
                                    window[s.function]()
                                } catch (e) {
                                    o = e, r = "The browser thrown the following error after calling " + s.function+"() JavaScript function."
                                }
                        }
                        r && console.error('LayerSlider: Error while calling layer action "' + s.action + '". ' + r + ("" !== o ? "\n\r\n\r" : ""), o)
                    }
                },
                smartLinks: function(e) {
                    var i = e.attr("href"),
                        t = e.attr("target"),
                        a = "";
                    if (t && -1 !== t.indexOf("ls-scroll")) {
                        switch (i) {
                            case "pagetop":
                                a = "Scroll to page top";
                                break;
                            case "pagebottom":
                                a = "Scroll to page bottom";
                                break;
                            case "slidertop":
                                a = "Scroll to the top of the slider";
                                break;
                            case "":
                            case "sliderbottom":
                                a = "Scroll to the bottom of the slider";
                                break;
                            default:
                                a = "Scroll to a specified location on the page"
                        }
                        Z.layers.set.ariaLabel(e, a), e.on("click." + B, function(e) {
                            e.preventDefault();
                            var t, e = document.body.scrollHeight - Z.device.viewportHeight;
                            if (i) switch (i) {
                                case "pagetop":
                                    t = 0;
                                    break;
                                case "pagebottom":
                                    t = Z.device.docHeight - Z.device.viewportHeight;
                                    break;
                                case "slidertop":
                                    t = Z.slider.offsetTop;
                                    break;
                                case "":
                                case "sliderbottom":
                                    t = Z.slider.offsetTop + Z.slider.height;
                                    break;
                                default:
                                    t = ee(i).filter(":visible").last().length ? ee(i).filter(":visible").last().offset().top : Z.slider.offsetTop + Z.slider.height
                            }
                            t += Z.o.scrollModifier, t = Math.min(t, e), t = Math.max(0, t), J.TweenMax.to("html, body", 1, {
                                scrollTop: t,
                                ease: J.Quint.easeInOut
                            })
                        })
                    }
                    if (-1 !== Z.defaults.init.controls.indexOf(i.toLowerCase()) || i.match(/^\#[0-9]/)) {
                        var s = ee.trim(i.toLowerCase().split("#")[1]),
                            r = parseInt(s);
                        switch (s) {
                            case "playmedia":
                                a = "play active media elements on current slide";
                                break;
                            case "pausemedia":
                                a = "pause active media elements on current slide";
                                break;
                            case "prev":
                                a = "jump to the previous slide";
                                break;
                            case "next":
                                a = "jump to the next slide";
                                break;
                            case "start":
                                a = "start slideshow";
                                break;
                            case "stop":
                                a = "stop slideshow";
                                break;
                            case "replay":
                                a = "replay slide";
                                break;
                            case "reverse":
                                a = "reverse slide";
                                break;
                            case "reverse-replay":
                            case "reversereplay":
                                a = "reverse, than replay slide";
                                break;
                            default:
                                "number" == typeof r && r == r && (a = "jump to slide " + r)
                        }
                        Z.layers.set.ariaLabel(e, a), e.on("click." + B, function(e) {
                            if (e.preventDefault(), -1 !== ["prev", "next", "start", "stop"].indexOf(s)) Z.navigation[s]("clicked");
                            else if ("number" == typeof r && r == r) Z.slideshow.changeTo(r, !0, !0);
                            else if (!Z.slider.state.changingSlides) switch (s) {
                                case "replay":
                                    Z.api.methods("replay");
                                    break;
                                case "reverse":
                                    Z.api.methods("reverse");
                                    break;
                                case "reverse-replay":
                                case "reversereplay":
                                    Z.api.methods("reverse", !0);
                                    break;
                                case "playmedia":
                                    Z.media.functions.playActiveMedia();
                                    break;
                                case "pausemedia":
                                    Z.media.functions.pauseActiveMedia();
                                    break;
                                case "unmute":
                                case "unmutemedia":
                                    Z.media.unmute.multipleMediaElements()
                            }
                        })
                    }
                },
                ariaLabel: function(e, t) {
                    e.attr("aria-label") || e.attr("aria-label", t)
                },
                linkTo: function(e) {
                    for (var t = e.attr("class").split(" "), i = 1, a = 0; a < t.length; a++) - 1 != t[a].indexOf("ls-linkto-") && (i = parseInt(t[a].split("ls-linkto-")[1]));
                    e.data(Z.defaults.init.dataKey).settings.linkedToSlide = i, e.css({
                        cursor: "pointer"
                    }).on("click." + B, function(e) {
                        e.preventDefault(), $.layerSlider(ee(this).data(Z.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(Z.defaults.init.dataKey, {}), t.settings.wrapperData = t.elements.$wrapper.data(Z.defaults.init.dataKey), t.elements.$clipWrapper = e.closest(".ls-clip"), t.elements.$clipWrapper.data(Z.defaults.init.dataKey, {}), t.settings.clipWrapperData = t.elements.$clipWrapper.data(Z.defaults.init.dataKey), t.elements.$loopWrapper = e.closest(".ls-loop"), t.elements.$loopWrapper.data(Z.defaults.init.dataKey, {}), t.settings.loopWrapperData = t.elements.$loopWrapper.data(Z.defaults.init.dataKey)), t.parallax.enabled && (t.elements.$parallaxWrapper = e.closest(".ls-parallax"), t.elements.$parallaxWrapper.data(Z.defaults.init.dataKey, {
                        parallax: {}
                    }), t.settings.parallaxWrapperData = t.elements.$parallaxWrapper.data(Z.defaults.init.dataKey), Z.transitions.layers.parallax.addLayer(t.elements.$parallaxWrapper, t.settings.parallaxWrapperData.parallax, t, i)), t.scroll.enabled && (t.elements.$scrollWrapper = e.closest(".ls-scroll"), t.elements.$scrollTransformWrapper = e.closest(".ls-scroll-transform"), t.elements.$scrollWrapper.data(Z.defaults.init.dataKey, {
                        scroll: {}
                    }), t.settings.scrollWrapperData = t.elements.$scrollWrapper.data(Z.defaults.init.dataKey), Z.transitions.layers.scroll.addLayer(t.elements.$scrollWrapper, t.settings.scrollWrapperData.scroll, t, i)), t.hover.enabled && !Z.slides[i].data.globalhover && Z.transitions.layers.hover.set(e, t), t.elements.$outerWrapper = e.closest(".ls-z"), t.elements.$outerStyleWrapper = t.elements.$outerWrapper.find("> .ls-wrapper"), t.elements.$outerWrapper.attr("data-slide-index", i), t.elements.$innerWrapper = e.closest(".ls-wrapper").addClass("ls-inner-wrapper"), t.elements.$_innerWrappers = t.elements.$outerWrapper.find(".ls-wrapper"), t.elements.$_allWrappers = t.elements.$outerWrapper.add(t.elements.$_innerWrappers), t.elements.$_outerWrappers = t.elements.$outerWrapper.add(t.elements.$outerWrapper.find(".ls-wrapper:not(.ls-inner-wrapper)"))
                },
                singleLayer: function(e, t) {
                    Z.layers.set.style(e), Z.layers.set.properties(e, t), Z.layers.set.dataAttribute(e, "hidden"), e.data("hasBeenSet", !0)
                },
                style: function(e) {
                    var t, i, a, s, r, o, n, l, d, c, u, p = e[0],
                        h = e.data(Z.defaults.init.dataKey),
                        m = p.style,
                        f = Z.layers,
                        g = 0,
                        y = 0,
                        v = !1,
                        b = parseFloat(e.css("font-size")),
                        w = p.getBoundingClientRect(),
                        S = "" !== m.paddingLeft ? f.getStyle(m.paddingLeft, Z.slider.initial.percW) : f.getStyle(e.css("padding-left"), Z.slider.initial.percW),
                        x = "" !== m.paddingRight ? f.getStyle(m.paddingRight, Z.slider.initial.percW) : f.getStyle(e.css("padding-right"), Z.slider.initial.percW),
                        T = "" !== m.paddingTop ? f.getStyle(m.paddingTop, Z.slider.initial.percH) : f.getStyle(e.css("padding-top"), Z.slider.initial.percH),
                        C = "" !== m.paddingBottom ? f.getStyle(m.paddingBottom, Z.slider.initial.percH) : f.getStyle(e.css("padding-bottom"), Z.slider.initial.percH),
                        k = "" !== m.marginLeft ? f.getStyle(m.marginLeft, Z.slider.initial.percW) : f.getStyle(e.css("margin-left"), Z.slider.initial.percW),
                        O = "" !== m.marginTop ? f.getStyle(m.marginTop, Z.slider.initial.percH) : f.getStyle(e.css("margin-top"), Z.slider.initial.percH);
                    p.style.margin = "0", r = "" !== m.borderLeftWidth ? f.getStyle(m.borderLeftWidth, Z.slider.initial.percW) : f.getStyle(e.css("border-left-width"), Z.slider.initial.percW), n = "" !== m.borderRightWidth ? f.getStyle(m.borderRightWidth, Z.slider.initial.percW) : f.getStyle(e.css("border-right-width"), Z.slider.initial.percW), o = "" !== m.borderTopWidth ? f.getStyle(m.borderTopWidth, Z.slider.initial.percH) : f.getStyle(e.css("border-top-width"), Z.slider.initial.percH), l = "" !== m.borderBottomWidth ? f.getStyle(m.borderBottomWidth, Z.slider.initial.percH) : f.getStyle(e.css("border-bottom-width"), Z.slider.initial.percH), 1 !== Z.media.properties.$allMediaLayers.filter(e).length && !e.children("iframe").length || (u = (c = e.children()).attr("width") ? c.attr("width") : c.width(), P = c.attr("height") ? c.attr("height") : c.height(), 300 === parseInt(u) && 150 === parseInt(P) && (u = 640, P = 360), "" !== p.style.width && "auto" !== p.style.width || e.css("width", u), "" !== p.style.height && "auto" !== p.style.height || e.css("height", P), "100%" === m.width && "100%" === m.height && (m.left = "50%", m.top = "50%", h.mediaSettings.fullsize = !0), v = u / P, c.css({
                        width: "100%",
                        height: "100%"
                    }));
                    var P = h.attributes;
                    e.is("img") && (d = (a = e.data("preloadedWidth")) / (s = e.data("preloadedHeight")), (!m.width && !m.height || "auto" === m.width && "auto" === m.height) && P && (P.width && P.height ? (t = -1 === P.width.indexOf("%") ? parseInt(P.width) : (g = parseInt(P.width), f.getStyle(P.width, Z.slider.initial.percW)), i = -1 === P.height.indexOf("%") ? parseInt(P.height) : (y = parseInt(P.height), f.getStyle(P.height, Z.slider.initial.percH))) : P.maxWidth && (e[0].style.width = P.maxWidth + "px", t = P.maxWidth, i = e.height()))), c = w.width ? w.width / (window.LS_previewZoom || 1) : (w.right - w.left) / (window.LS_previewZoom || 1), w = w.height ? w.height / (window.LS_previewZoom || 1) : (w.bottom - w.top) / (window.LS_previewZoom || 1), t || (t = m.width, -1 !== m.width.indexOf("%") && (g = parseInt(m.width)), t = (t = "" !== t && "auto" !== t ? f.getStyle(t, Z.slider.initial.percW) : c - Z.layers.toNum(S, b) - Z.layers.toNum(x, b) - Z.layers.toNum(r, b) - Z.layers.toNum(n, b)) || "auto"), i || (i = m.height, -1 !== m.height.indexOf("%") && (y = parseInt(m.height)), i = (i = "" !== i && "auto" !== i ? f.getStyle(i, Z.slider.initial.percH) : w - Z.layers.toNum(T, b) - Z.layers.toNum(C, b) - Z.layers.toNum(o, b) - Z.layers.toNum(l, b)) || "auto"), v = v || ("auto" !== t && "auto" !== i ? t / i : "auto"), !e.is("img") || m.width || m.height || P && (!P || P.width || P.height) || a === t && s === i || (a !== t ? i = (t = 5 < a ? a : t) / (v = 5 < a ? d : v) : s !== i && (t = (i = 5 < s ? s : i) * (v = 5 < s ? d : v))), parseFloat(e.css("opacity")), s = "" !== m.clip && m.clip, m.clip = "", d = m.webkitFilter || m.filter;
                    h.original = {
                        clip: s,
                        clipShouldBeConverted: !1,
                        left: m.left || "0",
                        top: m.top || "0",
                        width: "auto" !== t ? parseFloat(t) : "auto",
                        height: "auto" !== i ? parseFloat(i) : "auto",
                        sWidth: m.width,
                        sHeight: m.height,
                        percentWidth: g,
                        percentHeight: y,
                        backgroundColor: m.backgroundColor,
                        backgroundImage: m.backgroundImage,
                        backgroundSize: m.backgroundSize,
                        backgroundRepeat: m.backgroundRepeat,
                        backgroundPosition: m.backgroundPosition,
                        ratio: v,
                        paddingLeft: S,
                        paddingTop: T,
                        paddingRight: x,
                        paddingBottom: C,
                        marginLeft: k,
                        marginTop: O,
                        borderLeftWidth: r,
                        borderTopWidth: o,
                        borderRightWidth: n,
                        borderBottomWidth: l,
                        borderRadius: function(r, o) {
                            let n = ["borderTopLeftRadius", "borderTopRightRadius", "borderBottomRightRadius", "borderBottomLeftRadius"],
                                l = "";
                            return o.borderRadius && (-1 === o.borderRadius.indexOf("/") ? ee.each(["border-top-left-radius", "border-top-right-radius", "border-bottom-right-radius", "border-bottom-left-radius"], function(e, t) {
                                let i = o[n[e]],
                                    a = r.css(t),
                                    s = ee.trim(void 0 !== i && i.length ? i : a); - 1 == s.indexOf(" ") && -1 == s.indexOf("em") && -1 == s.indexOf("%") && (s = parseInt(s)), l += s + " "
                            }) : l = o.borderRadius), ee.trim(l)
                        }(e, m),
                        fontSize: b,
                        lineHeight: p.style.lineHeight,
                        letterSpacing: p.style.letterSpacing,
                        textStrokeWidth: p.style.textStrokeWidth || p.style.webkitTextStrokeWidth,
                        color: e.css("color"),
                        zIndex: parseInt(e.css("z-index")) || "auto",
                        filter: d,
                        backgroundColor: e.css("background-color"),
                        dataLS: e.attr("data-ls") || "",
                        styles: e.attr("style") || ""
                    }, m.zIndex = "auto", h.responsive = {
                        left: m.left || "0",
                        top: m.top || "0",
                        width: t,
                        height: i
                    }
                },
                properties: function(e, t, i) {
                    t = t || e.data("slideIndex");
                    var a = e.data(Z.defaults.init.dataKey);
                    e.data("ls");
                    if (a.is.textLayer = !(e.is("img") || a.is.mediaLayer || a.is.backgroundVideo), (a.self = e).data("ls"))
                        for (var s = Z.defaults.layer.keys, r = e.data("ls").split(";"), o = e.data("ls").split(";"), n = 0; n < o.length; n++)
                            if (ee.trim(o[n])) {
                                var l = o[n].indexOf(":"),
                                    d = [o[n].substring(0, l), o[n].substring(l + 1)],
                                    c = null,
                                    u = null,
                                    p = null,
                                    h = null,
                                    m = null;
                                if (d[0] = ee.trim(d[0].toLowerCase()), -1 == ["thumbnail", "poster"].indexOf(d[0]) && (d[1] = d[1].toLowerCase()), "" !== (c = d[0]))
                                    if (void 0 !== s[c = c.replace("split", "text")]) {
                                        if (u = s[c][0], m = "overlay" === c ? ee.trim(r[n].substring(l + 1)) : Z.functions.convert.properties(ee.trim(d[1])), -1 !== c.indexOf("mirror") && (m = Z.layers.set.mirrorTransitions(ee.trim(d[1]))), d[1] && -1 !== d[1].indexOf("random") && (c.match(/(text)/) || (m = Z.functions.convert.randomProperties(m, u)), a.should.update || (a.should.update = !0)), "number" == typeof m && u.match(/(duration|startat|shift|delay)/i) && (m /= 1e3), c.match(/(fade)(.+)/)) switch (m) {
                                            case !0:
                                                m = 0;
                                                break;
                                            case !1:
                                                m = 1
                                        }
                                        void 0 !== (h = s[c][1]) ? "" !== m ? "object" == typeof m && -1 == c.indexOf("mirror") ? c.match(/(text)/) ? h.match(/(converted)/i) ? a[h][u] = m : a[h].cycle[u] = m : (p = Z.functions.convert.properties(ee.trim(m[0])), Z.debugMode && Z.debug.add("warn", "layerInit.prop1", [c, m, p]), "number" == typeof p && u.match(/(duration|startat|shift|delay)/i) && (p /= 1e3), a[h][u] = p) : c.match(/(text)/) && -1 !== m.toString().indexOf("random") ? a[h].random[u] = m : a[h][u] = m : Z.debugMode && Z.debug.add("warn", "layerInit.prop2", c) : a[u][c] = m
                                    } else "clip" === c ? (a.original.clip = d[1], a.original.clipShouldBeConverted = !0) : Z.debugMode && Z.debug.add("warn", "layerInit.prop4", c)
                            }
                    if (Z.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 = Z.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 = Z.functions.convert.easing(a.out.ease)), ee.isNumeric(a.loop.count) && (0 < a.loop.count || -1 === a.loop.count) && !1 !== a.loop.enabled ? (a.loop.enabled = !0, a.loopTo.ease = a.loopClipTo.ease = Z.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, (!ee.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 = Z.functions.convert.easing(a.hover.easeIn), a.hover.easeOut = Z.functions.convert.easing(a.hover.easeOut, !0), a.hover.durationOut || (a.hover.durationOut = a.hover.durationIn), J.TweenMax.set(e[0], {
                            autoCSS: !1,
                            css: {
                                transformPerspective: a.hoverShouldBeConverted.transformPerspective
                            }
                        })) : a.hover.enabled = !1, a.parallax.level && ee.isNumeric(a.parallax.level) && 0 !== a.parallax.level && !1 !== a.parallax.enabled ? a.parallax.enabled = !0 : a.parallax.enabled = !1, a.is.slideBackground) {
                        var f = {
                            scale: 1,
                            rotation: 0
                        };
                        if (Z.slides[t].kenBurns.zoom && (a.kenBurns = Z.slides[t].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 = f;
                                    break;
                                case "in":
                                    a.kenBurns.from = f, 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 = f, a.kenBurns.to = f;
                        ee.isEmptyObject(Z.slides[t].filter) || (Z.slides[t].filter.from && (a.filter.values.bgFrom = Z.transitions.layers.filters.convert(Z.slides[t].filter.from)), Z.slides[t].filter.to && (a.filter.values.bgTo = Z.transitions.layers.filters.convert(Z.slides[t].filter.to)))
                    }
                    if (a.textIn.type && -1 === Z.defaults.layer.splitTypeKeys.indexOf(a.textIn.type) && (Z.debugMode && Z.debug.add("warn", "layerInit.splitType3a", [e[0].tagName, a.textIn.type]), delete a.textIn.type, delete a.textIn.ns, a.textIn.enabled = !1), a.textOut.type && -1 === Z.defaults.layer.splitTypeKeys.indexOf(a.textOut.type) && (Z.debugMode && Z.debug.add("warn", "layerInit.splitType3b", [e[0].tagName, a.textOut.type]), delete a.textOut.type, delete a.textOut.ns, a.textOut.enabled = !1), a.textIn.type || a.textOut.type) {
                        var g = 0;
                        if (a.is.textLayer ? (a.textIn.type && (a.textIn.enabled = !0, a.textInNodesTo.ease = Z.functions.convert.easing(a.textInNodesTo.ease), a.textIn.split = a.textIn.type.split("_")[0], e.children().length && Z.debugMode && (g = 1)), a.textOut.type && !Z.o.inLayerPreview && (a.textOut.enabled = !0), a.textOut.enabled && (a.textOutNodesTo.ease = Z.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], e.children().length && Z.debugMode && (g = 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, Z.debugMode && (g = 2)), Z.debugMode && 0 !== g && t && !i) switch (g) {
                            case 1:
                                Z.debug.add("warn", "layerInit.splitType1", [e.prop("nodeName"), t]);
                                break;
                            case 2:
                                Z.debug.add("warn", "layerInit.splitType2", [t, e.prop("nodeName")])
                        }
                    }(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 = Z.transitions.layers.filters.convert(a.inLayerStyleShouldBeConvertedFrom.filter)), a.filter.values.style = Z.transitions.layers.filters.convert(a.original.filter), a.outLayerStyleShouldBeConvertedTo.filter && (a.filter.values.out = Z.transitions.layers.filters.convert(a.outLayerStyleShouldBeConvertedTo.filter)), a.loopLayerShouldBeConverted.filter && (a.filter.values.loop = Z.transitions.layers.filters.convert(a.loopLayerShouldBeConverted.filter)), a.hoverShouldBeConverted.filter && (a.filter.values.hover = Z.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), e.attr("data-ls-slidein", t), void 0 !== a.settings.static && "none" !== a.settings.static ? (0 !== (g = parseInt(a.settings.static)) && "forever" !== a.settings.static ? (e.attr("data-ls-slideout", g), a.settings.slideOut = g) : a.settings.slideOut = 0, a.is.static = !0, e.attr("data-ls-static", "1")) : e.attr("data-ls-slideout", t), a.is.mediaLayer && e.children("video, audio").length && Z.media.html5.singleInit(e.children("video, audio").eq(0)), a.is.backgroundVideo && a.styleSettings.overlay && e.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))
                },
                dataAttribute: function(e, t) {
                    e.removeAttr("data-ls-animating-in data-ls-active data-ls-animating-out data-ls-hidden"), e.attr("data-ls-" + t, "")
                }
            },
            get: function(e) {
                var t, i, a, s, r, o = this.$all;
                return e && (t = "in", a = i = "", s = ':not(".ls-bg")', r = ':not(".ls-bg-video")', -1 == (e = e.toLowerCase()).indexOf("bgvideo") && -1 == e.indexOf("backgroundvideo") || (r = "", 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") && (t = "out"), -1 == e.indexOf("img") && -1 == e.indexOf("image") || (i = "img"), -1 == e.indexOf("bg") && -1 == e.indexOf("background") && -1 == e.indexOf("bgonly") || (s = ""), o = -1 != e.indexOf("current") ? o.filter(i + "[data-ls-slide" + t + '="' + Z.slides.current.index + '"]' + s + r) : -1 != e.indexOf("next") ? o.filter(i + "[data-ls-slide" + t + '="' + Z.slides.next.index + '"]' + s + r) : o.filter(i + s + r), -1 != e.indexOf("notactive") && (o = o.filter(".ls-bg, .ls-bg-video, :hidden"), e = e.replace("notactive", "")), -1 != e.indexOf("active") && (o = o.filter(":visible:not(.ls-bg, .ls-bg-video)"), e = e.replace("active", "")), -1 != e.indexOf("notstatic") && (o = o.filter(':not([data-ls-static="1"])'), e = e.replace("notstatic", "")), -1 != e.indexOf("static") && (o = o.filter('[data-ls-static="1"]'), e = e.replace("static", "")), -1 != e.indexOf("bgonly") && (o = o.filter(".ls-bg"), e = e.replace("bgonly", "")), "" !== a && (o = o.find(a))), o
            },
            update: {
                data: function(e, t, i) {
                    var a, s, r;
                    switch (e instanceof jQuery || (e = ee(e)), i && e.attr("data-ls", i).data("ls", i), a = (s = e.data(Z.defaults.init.dataKey)).is.onSlide, r = s.original, t) {
                        default:
                            case "transitions":
                            s.settings.timelineIsCalculated = !1,
                        Z.layers.set.properties(e, a, !0);
                        break;
                        case "all":
                                e.data(Z.defaults.init.dataKey, new Z.defaults.layer.options(e, a)),
                            (s = e.data(Z.defaults.init.dataKey)).original = r,
                            Z.layers.set.properties(e, a, !0),
                            Z.layers.set.wrappers(e, s, a)
                    }
                }
            },
            wrap: function(p, e) {
                var t, h;
                Z.slides[p].wrapped || "wrapping" === Z.slides[p].wrapped || (Z.slides[p].wrapped = "wrapping", t = e ? 25 : 0, e = Z.slides[p].$layers, h = e.length, e.each(function(c, u) {
                    Z.timeouts["slide-" + p + "-layer-" + c] = setTimeout(function() {
                        delete Z.timeouts["slide-" + p + "-layer-" + c];
                        var e = ee(u),
                            t = e,
                            i = "",
                            a = !1,
                            s = "";
                        e.hasClass("ls-hide-phone") && (s += " ls-hide-on-phone"), e.hasClass("ls-hide-tablet") && (s += " ls-hide-on-tablet"), e.hasClass("ls-hide-desktop") && (s += " ls-hide-on-desktop"), e.removeClass("ls-hide-phone ls-hide-tablet ls-hide-desktop"), t.is("a") && 1 === t.children().length && (a = !0, e = t.find(".ls-layer"));
                        var r, o, n, l = e.data(Z.defaults.init.dataKey);
                        if (!l) return !0;
                        d = e.data("$layerGroup") || Z.slider.$layersWrapper, l.is.backgroundVideo ? d = Z.slider.$bgVideosWrapper : l.is.slideBackground && (d = Z.slider.$slideBGWrapper), e.data("hasBeenSet") || Z.layers.set.singleLayer(e, p), l.textIn.split && (n = new J.SplitType(e[0], {
                            split: l.textIn.split
                        }), l.textIn.type && (l.textIn.ns = n[l.textIn.type.split("_")[0]]), l.textOut.type && (l.textOut.ns = n[l.textOut.type.split("_")[0]]), -1 !== e.css("background-clip").indexOf("text") && (r = e.find(".char"), o = e.find(".word"), n = e.find(".line"), l.textIn.$nodesForBackgroundClip = r.length ? r : o.length ? o : n, r.length ? e.addClass("ls-has-chars") : o.length ? e.addClass("ls-has-words") : e.addClass("ls-has-lines"), l.textIn.$nodesForBackgroundClip.each(function() {
                            var e = ee(this),
                                t = ee.trim(e.text()),
                                i = document.createTextNode(t),
                                t = ee(i),
                                i = ee('<div class="ls-textnode-bgclip-wrap"><div class="ls-textnode"></div></div>').css({
                                    backgroundColor: l.original.backgroundColor,
                                    backgroundImage: l.original.backgroundImage,
                                    backgroundSize: l.original.backgroundSize,
                                    backgroundRepeat: l.original.backgroundRepeat,
                                    backgroundPosition: l.original.backgroundPosition
                                });
                            e.css({
                                verticalAlign: "top"
                            }).text(""), t.clone().appendTo(e).wrap('<div class="ls-textnode-dummy"></div>'), t.appendTo(e).wrap(i)
                        }))), i = l.is.slideBackground || l.is.backgroundVideo ? '<div class="ls-wrapper ls-bg-outer"><div class="ls-wrapper ls-bg-wrap"></div></div>' : (l.clip.enabled && (i = '<div class="ls-wrapper ls-clip"></div>'), l.loop.enabled && (i = '<div class="ls-wrapper ls-loop">' + i + "</div>"), l.scroll.enabled && (i = '<div class="ls-wrapper ls-scroll"><div class="ls-wrapper ls-scroll-transform">' + i + "</div></div>"), '<div class="ls-wrapper ls-in-out">' + i + "</div>"), l.parallax.enabled && (i = '<div class="ls-wrapper ls-parallax">' + i + "</div>"), "" !== (i = '<div class="ls-wrapper ls-z">' + i + "</div>") ? e.appendTo(d).wrap(i) : e.appendTo(d), !0 === a && t.addClass("ls-layer-link").appendTo(e.parent());
                        var d = {},
                            a = e.css("mix-blend-mode");
                        a && "normal" !== a && (d["mix-blend-mode"] = a, e.css("mix-blend-mode", "normal")), l.original.customZIndex = 1;
                        a = parseInt(l.original.zIndex);
                        l.is.backgroundVideo || l.is.slideBackground ? d = {
                            zIndex: l.original.customZIndex
                        } : (a = a || c + 101, d.zIndex = a, l.original.customZIndex = a), Z.browser.isSafari && (d.transform = "translateZ(" + 3e3 * a + "px )"), Z.layers.set.wrappers(e, l, p), l.elements.$outerWrapper.css(d).addClass(s), l.styleSettings.pointerevents && l.elements.$innerWrapper.css("pointer-events", "none"), l.is.slideBackground && l.elements.$bgWrapper.css({
                            backgroundColor: Z.slides[p].data.backgroundColor
                        }), Z.layers.$all = Z.layers.$all.add(e), Z.slides[p].$layers = Z.slides[p].$layers.not(t), c === h - 1 && ($.children(".ls-slide").eq(p - 1).empty(), Z.slides[p].wrapped = !0)
                    }, t * (c + 1))
                }))
            }
        }, Z.slideshow = {
            direction: "next",
            nextLoop: 0,
            firstStart: !0,
            forceFastChange: !1,
            sequence: {
                normal: [],
                randomized: []
            },
            state: {
                changed: -1,
                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 == Z.slides.count && (Z.o.autoStart = !1, Z.o.navPrevNext = !1, Z.o.navStartStop = !1, Z.o.navButtons = !1, Z.o.cycles = -1, Z.o.forceLoopNum = !1, Z.o.autoPauseSlideshow = !0, Z.o.firstSlide = 1, Z.o.thumbnailNavigation = "disabled"), Z.o.autoStart && 1 != Z.slides.count || Z.functions.setStates(this, {
                    running: !1,
                    paused: !0
                }), this.set.pauseOnHover(), this.set.sequences()
            },
            set: {
                pauseOnHover: function() {
                    Z.o.pauseOnHover = !0 === Z.o.pauseOnHover ? "slideshowOnly" : Z.o.pauseOnHover, !1 !== Z.o.pauseOnHover && $.on("mouseenter." + B, function() {
                        Z.slider.state.inFullscreen || (Z.functions.setStates(Z.slideshow, {
                            pausedByHover: !0
                        }), "slideshowOnly" !== Z.o.pauseOnHover && Z.transitions.layers.timeline.pause())
                    }).on("mouseleave." + B, function() {
                        var e = 1;
                        Z.transitions._slideTimeline && Z.transitions._slideTimeline.duration() > Z.transitions.layers.timeline.totalDuration && (e = Z.transitions.layers.timeline.totalDuration / Z.transitions._slideTimeline.duration()), Z.functions.setStates(Z.slideshow, {
                            pausedByHover: !1
                        }), ee("body").hasClass("ls-unselectable") || "slideshowOnly" === Z.o.pauseOnHover || Z.o.pauseLayers && Z.slideshow.isPaused() || Z.transitions.layers.timeline.resume(), Z.transitions._slideTimeline && Z.transitions.layers.timeline.state.finished && Z.transitions._slideTimeline.progress() < e && Z.functions.setStates(Z.transitions.layers.timeline, {
                            finished: !1
                        }), Z.slideshow.start()
                    })
                },
                sequences: function() {
                    for (var e = 0; e < Z.slides.count; e++) Z.slideshow.sequence.normal[e] = e + 1;
                    Z.slideshow.sequence.randomized = Z.functions.shuffleArray(ee.merge([], Z.slideshow.sequence.normal))
                },
                normalizedSequence: function() {
                    var e = Z.o.shuffleSlideshow ? "randomized" : "normal",
                        t = Z.slideshow.sequence[e],
                        i = Z.slideshow.sequence[e].length,
                        a = t.indexOf(Z.slides.first.index);
                    Z.slideshow.sequence.normalized = [];
                    for (var s = a; s < i; s++) Z.slideshow.sequence.normalized.push(t[s]);
                    for (var r = 0; r < a; r++) Z.slideshow.sequence.normalized.push(t[r])
                },
                prevNext: function(e) {
                    switch (e) {
                        case "prev":
                            Z.o.twoWaySlideshow && (Z.slideshow.direction = "prev"), Z.slideshow.changeTo(Z.slideshow.get.slideInSequence("prev"), !0);
                            break;
                        case "next":
                            Z.slideshow.direction = "next", Z.slideshow.changeTo(Z.slideshow.get.slideInSequence("next"), !0)
                    }
                }
            },
            get: {
                sequence: function() {
                    var e = "normal";
                    return Z.o.playByScroll ? e = "normalized" : Z.o.shuffleSlideshow && (e = "randomized"), e
                },
                slideInSequence: function(e) {
                    var t = Z.slideshow.sequence[this.sequence()],
                        i = t.indexOf(Z.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 Z.slideshow.sequence[this.sequence()].indexOf(e)
                }
            },
            cycles: {set: function() {
                    0 < Z.o.cycles && (Z.slideshow.curCycle = 1, Z.slideshow.cycleSlideIndex = Z.slideshow.get.indexOfSlideInSequence(Z.slides.first.index))
                },
                check: function(e) {
                    if (Z.slideshow.get.indexOfSlideInSequence(e) === Z.slideshow.cycleSlideIndex) return ++Z.slideshow.curCycle === Z.o.cycles + 1
                }
            },
            start: function(e) {
                !this.isPaused() && Z.transitions._slideTimeline && Z.transitions.layers.timeline.state.finished && this.changeTo(Z.slides.next.index)
            },
            stop: function() {
                Z.functions.setStates(this, {
                    running: !1,
                    paused: !0
                })
            },
            changeTo: function(e, t, i) {
                if (!document.body.contains(I)) return !1;
                if (Z.slides.current.index === e && !Z.slideshow.forceSlideChangeTo) return !1;
                if (Z.slideshow.forceSlideChangeTo = null, !this.firstStart && Z.api.hasEvent("slideChangeWillStart")) {
                    var a = Z.api.triggerEvent("slideChangeWillStart", Z.api.eventData());
                    if (!1 === a) return;
                    ee.isNumeric(a) && (e = parseInt(a))
                }
                e > Z.slides.count || e < 1 ? Z.debugMode && (Z.debug.add("group", "slideshow"), Z.debug.add("warn", "slideshow.invalidSlideIndex", [e, Z.slides.count]), Z.debug.groupEnd()) : Z.slider.isBusy() || Z.slideshow.state.pausedByVideo && !t ? !Z.slider.state.preloadingImages && Z.slider.state.animatingSlides && Z.transitions._slideTransition && (Z.slideshow.forceSlideChangeTo = e, Z.slideshow.should.change = !0, Z.transitions._slideTransition.progress(1), Z.transitions.timelines.set("currentforce", function(e, t) {
                    e.progress(1)
                })) : (Z.functions.setStates(Z.transitions.layers.timeline, {
                    finished: !1
                }), Z.slideshow.should.change = !1, Z.debugMode && Z.debug.add("group", "slideshow"), t ? ("prev" === Z.navigation.direction && Z.o.twoWaySlideshow && (Z.slideshow.direction = "prev"), Z.debugMode && (Z.debug.add("log", "slideshow.changedByUser", !1), Z.o.twoWaySlideshow && Z.debug.add("log", "slideshow.setdir", Z.slideshow.direction))) : Z.navigation.direction = Z.slideshow.direction, Z.transitions.timers.reverse(), Z.gui.media.hideUnmute(), Z.slides.set.nextSlideIndex(e), Z.debugMode && (Z.debug.add("log", "slideshow.change", [Z.slides.current.index, Z.slides.next.index, Z.slideshow.direction, Z.navigation.direction]), Z.debug.groupEnd()), Z.functions.setStates(this, {
                    pausedByVideo: !1,
                    changed: ++this.state.changed
                }), Z.functions.setStates(Z.slider, {
                    changingSlides: !0
                }), Z.slider.state.animatingSlides && Z.transitions._slideTransition && Z.transitions.timelines.set("currentforce", function(e, t) {
                    e.progress(1)
                }), Z.preload.imagesOfSlide(Z.slides.next.index, function() {
                    Z.transitions.start()
                }))
            },
            forceStop: function() {
                Z.navigation.stop(), ee.each(Z.timeouts, function(e, t) {
                    clearTimeout(Z.timeouts[e])
                }), Z.transitions.timers.stop(), Z.transitions._slideTimeline.stop(), Z.transitions._slideTimelineAlternate.stop(), Z.functions.setStates(Z.transitions.layers.timeline, {
                    stopped: !0,
                    running: !1
                }), $.find("*").stop(!0, !1).dequeue()
            },
            restart: function() {
                $.find("*").stop(), Z.navigation.change(Z.slides.current.index, Z.slideshow.direction)
            }
        }, Z.media = {
            properties: {
                $allMediaLayers: ee(),
                playingInCurSlide: 0,
                endedInCurSlide: 0,
                userDidUnmute: !1
            },
            init: function() {
                Z.functions.setStates(Z.slider, {
                    waitingForYouTube: !1,
                    waitingForVimeo: !1
                }), Z.media.properties.allowToUnmute = !0, Z.media.youtube.init(), Z.media.vimeo.init(), Z.media.html5.init()
            },
            get: function(e) {
                var t, i = Z.media.properties.$allMediaLayers;
                return e && (-1 !== (e = e.toLowerCase()).indexOf("notbg") && (i = i.not(".ls-bg-video")), -1 !== e.indexOf("active") && (i = i.filter("[data-ls-active], [data-ls-animating-in]")), -1 !== e.indexOf("notstatic") && (i = i.not("[data-ls-static]")), t = i.find("video, audio, iframe"), -1 !== e.indexOf("notplaying") ? t = t.filter("[data-ls-not-playing]") : -1 !== e.indexOf("playing") && (t = t.filter("[data-ls-playing]")), -1 !== e.indexOf("allowtounmute") && (t = t.filter("[data-ls-allow-to-unmute]")), -1 !== e.indexOf("mutedbybrowser") && (t = t.filter("[data-ls-muted-by-browser]"))), t
            },
            set: {
                backgroundVideo: function(e, t) {
                    0 === e.children(".ls-vpcontainer").length && (e = ee("<div>").addClass("ls-vpcontainer").appendTo(e), t.mediaSettings.poster && ee("<div>").appendTo(e).addClass("ls-videopreview").attr({
                        style: "background-image: url(" + t.mediaSettings.poster + ")"
                    }))
                },
                customPoster: function(e, t) {
                    return t.mediaSettings.poster || !1
                },
                dataAttribute: function(e, t) {
                    e.removeAttr("data-ls-playing data-ls-not-playing"), e.attr("data-ls-" + t, ""), Z.media.functions.checkSlideshowWaiting()
                },
                mediaElements: function(e, t, i) {
                    var a = ee("<div>").addClass("ls-vpcontainer").appendTo(e);
                    !("autoplay" in i.mediaSettings) && Z.o.autoPlayVideos || i.mediaSettings.autoplay ? e.addClass("ls-autoplay") : ee("<div>").appendTo(a).addClass("ls-playvideo"), t.is("iframe") && i.mediaProperties.poster && ee("<div>").appendTo(a).addClass("ls-videopreview").attr({
                        style: "background-image: url(" + i.mediaProperties.poster + ")"
                    }), t.is("video, audio") && i.mediaProperties.poster && ee("<div>").appendTo(a).addClass("ls-videopreview").attr({
                        style: "background-image: url(" + i.mediaProperties.poster + ")"
                    })
                },
                properties: function(e, t, i) {
                    switch (i.is.mediaLayer = !0, i.mediaProperties.type) {
                        case "youtube":
                            i.is.backgroundVideo ? (i.mediaProperties.options = ee.extend(!0, {
                                loop: 1,
                                playlist: i.mediaProperties.embedID,
                                controls: 0,
                                autoplay: 0,
                                showinfo: !1,
                                modestbranding: 1,
                                thumbnail: !1
                            }, Z.media[i.mediaProperties.type].defaults, i.mediaProperties.embedOptions), Z.media.set.backgroundVideo(e, i)) : (i.mediaProperties.options = ee.extend(!0, {}, Z.media[i.mediaProperties.type].defaults, i.mediaProperties.embedOptions, {
                                autoplay: 0
                            }), Z.media.set.mediaElements(e, t, i));
                            break;
                        case "vimeo":
                            i.is.backgroundVideo ? (i.mediaProperties.options = ee.extend(!0, {
                                loop: 1,
                                byline: 0,
                                portrait: 0,
                                title: 0,
                                fun: 0
                            }, Z.media[i.mediaProperties.type].defaults, i.mediaProperties.embedOptions), Z.media.set.backgroundVideo(e, i)) : (i.mediaProperties.options = ee.extend(!0, {}, Z.media[i.mediaProperties.type].defaults, i.mediaProperties.embedOptions, {
                                autoplay: 0
                            }), Z.media.set.mediaElements(e, t, i));
                            break;
                        case "html5":
                            t.attr("autoplay") && (t.removeAttr("autoplay"), e.attr("data-ls", e.attr("data-ls") + " autoplay: true;")), i.is.backgroundVideo && (t.removeAttr("controls"), t[0].muted = !0, t.attr("loop", "")), "controls" in i.mediaSettings && (i.mediaSettings.controls ? (t.attr("controls", ""), t.removeAttr("nocontrols")) : t.removeAttr("controls")), "volume" in i.mediaSettings && (i.mediaSettings.volume < 0 ? i.mediaSettings.volume = 0 : 100 < i.mediaSettings.volume && (i.mediaSettings.volume = 100), t[0].volume = i.mediaSettings.volume / 100), "muted" in i.mediaSettings && (i.mediaSettings.muted ? t[0].muted = !0 : t[0].muted = !1), "loop" in i.mediaSettings && (i.mediaSettings.loop ? t.attr("loop", "") : t.removeAttr("loop")), i.is.backgroundVideo ? Z.media.set.backgroundVideo(e, i) : Z.media.set.mediaElements(e, t, i)
                    }
                },
                thumbnail: function(e, t) {
                    switch (t) {
                        case "show":
                            e.fadeIn(Z.transitions.media.defaults.fadeIn);
                            break;
                        case "hide":
                            e.delay(Z.transitions.media.defaults.delay).fadeOut(Z.transitions.media.defaults.fadeOut)
                    }
                }
            },
            events: {
                start: function(e, t, i) {
                    var a;
                    Z.api.hasEvent("mediaDidStart") && !i.mediaProperties.alreadyStarted && Z.media.functions.allowedToPlay(e, i) && ((a = Z.api.eventData()).event.target = e[0], Z.api.triggerEvent("mediaDidStart", a), i.mediaProperties.alreadyStarted = !0)
                },
                stop: function(e, t, i) {
                    var a;
                    Z.api.hasEvent("mediaDidStop") && i.mediaProperties.alreadyStarted && ((a = Z.api.eventData()).event.target = e[0], Z.api.triggerEvent("mediaDidStop", a), i.mediaProperties.alreadyStarted = !1)
                }
            },
            unmute: {set: function(e, t, i) {
                    ("youtube" !== t && "vimeo" !== t || Z.media.properties.allowToUnmute) && Z.gui.media.showUnmute(), e.attr("data-ls-allow-to-unmute", ""), i && e.attr("data-ls-muted-by-browser", "")
                },
                multipleMediaElements: function() {
                    var e = $.find("[data-ls-allow-to-unmute]");
                    (Z.o.rememberUnmuteState ? e : e.filter("[data-ls-playing], [data-ls-muted-by-browser]")).each(function() {
                        Z.media.unmute.singleMediaElement(ee(this))
                    }), Z.gui.media.hideUnmute(), Z.media.properties.userDidUnmute = !0
                },
                singleMediaElement: function(e) {
                    var t, i = e.closest(".ls-layer").data(Z.defaults.init.dataKey),
                        a = !1;
                    switch (i.mediaProperties.type) {
                        case "youtube":
                            Z.media.properties.allowToUnmute && (a = !0, i.mediaProperties.player.unMute());
                            break;
                        case "vimeo":
                            Z.media.properties.allowToUnmute && (a = !0, t = i.mediaSettings.volume ? i.mediaSettings.volume / 100 : 1, i.mediaProperties.player.setVolume(t));
                            break;
                        case "html5":
                            a = !0, e[0].muted = !1
                    }
                    a && e.removeAttr("data-ls-muted-by-browser data-ls-allow-to-unmute")
                }
            },
            functions: {
                allowedToPlay: function(e, t) {
                    e = e.closest(".ls-layer");
                    return !!(Z.slides.current.index === parseInt(e.attr("data-ls-slidein")) || t.is.backgroundVideo && Z.slides.next.index === parseInt(e.attr("data-ls-slidein")) || e.attr("data-ls-static") && void 0 !== e.attr("data-ls-active"))
                },
                playActiveMedia: function() {
                    var e;
                    Z.media.get("notbg,active").each(function() {
                        if ((e = ee(this).closest(".ls-layer").data(Z.defaults.init.dataKey)).mediaProperties.alreadyStarted) switch (e.mediaProperties.type) {
                            case "youtube":
                                e.mediaProperties.player.playVideo();
                                break;
                            case "vimeo":
                                e.mediaProperties.player.play();
                                break;
                            case "html5":
                                e.mediaProperties.$media[0].play()
                        } else ee(this).parent().find(".ls-vpcontainer").trigger("playMedia")
                    })
                },
                pauseActiveMedia: function() {
                    var e;
                    Z.media.get("notbg,active,playing").each(function() {
                        switch ((e = ee(this).closest(".ls-layer").data(Z.defaults.init.dataKey)).mediaProperties.type) {
                            case "youtube":
                                e.mediaProperties.player.pauseVideo();
                                break;
                            case "vimeo":
                                e.mediaProperties.player.pause();
                                break;
                            case "html5":
                                this.pause()
                        }
                    })
                },
                urlToObject: function(e) {
                    var a = {},
                        e = e.split("?")[1];
                    return e && e.split("#")[0].replace(/([^=&]+)=([^&]*)/g, function(e, t, i) {
                        a[decodeURIComponent(t)] = ee.isNumeric(decodeURIComponent(i)) ? parseInt(decodeURIComponent(i)) : decodeURIComponent(i)
                    }), a
                },
                checkSlideshowState: function(e, t) {
                    !t.is.static && Z.o.autoPauseSlideshow && (Z.functions.setStates(Z.slideshow, {
                        pausedByVideo: !0
                    }), "auto" == Z.o.autoPauseSlideshow && Z.media.properties.playingInCurSlide++)
                },
                checkSlideshowWaiting: function() {
                    var e = Z.media.properties.playingInCurSlide,
                        t = Z.media.get("notbg,active,notstatic,notplaying"),
                        i = Z.media.get("notbg,active,notstatic,notplaying").length;
                    i === e && 0 < i && Z.slideshow.state.pausedByVideo && Z.o.autoPauseSlideshow && !Z.timeouts.pausedVideos && Z.slideshow.state.running ? Z.timeouts.pausedVideos = setTimeout(function() {
                        Z.slideshow.state.running ? t.each(function() {
                            Z.media.functions.mediaEnded(ee(this), ee(this).closest(".ls-layer"), ee(this).closest(".ls-layer").data(Z.defaults.init.dataKey))
                        }) : Z.slideshow.state.pausedByVideo = !1
                    }, 5e3) : Z.timeouts.pausedVideos && (clearTimeout(Z.timeouts.pausedVideos), delete Z.timeouts.pausedVideos)
                },
                playIfAllowed: function(e) {
                    var t = e.data(Z.defaults.init.dataKey);
                    t.is.mediaLayer && (Z.device.isMobile && ($.hasClass("ls-device-is-phone") && t.elements.$outerWrapper.hasClass("ls-hide-on-phone") || $.hasClass("ls-device-is-tablet") && t.elements.$outerWrapper.hasClass("ls-hide-on-tablet")) || ("autoplay" in t.mediaSettings || !Z.o.autoPlayVideos) && !t.mediaSettings.autoplay || e.find(".ls-vpcontainer").trigger("playMedia"))
                },
                stop: function(a) {
                    a = void 0 === a || a;
                    Z.layers.get("current,out,youtube").each(function() {
                        var e = ee(this),
                            t = e.closest(".ls-layer"),
                            i = t.data(Z.defaults.init.dataKey);
                        Z.media.youtube.stop(t, e, i, a)
                    }), Z.layers.get("current,out,vimeo").each(function() {
                        var e = ee(this),
                            t = e.closest(".ls-layer"),
                            i = t.data(Z.defaults.init.dataKey);
                        Z.media.vimeo.stop(t, e, i, a)
                    }), Z.layers.get("current,out,html5").each(function() {
                        var e = ee(this),
                            t = e.closest(".ls-layer"),
                            i = t.data(Z.defaults.init.dataKey);
                        Z.media.html5.stop(t, e, i, a)
                    }), Z.media.properties.playingInCurSlide = 0, Z.media.properties.endedInCurSlide = 0
                },
                mediaEnded: function(e, t, i) {
                    "auto" != Z.o.autoPauseSlideshow || i.is.backgroundVideo || (i.is.static || Z.media.properties.endedInCurSlide++, Z.media.properties.endedInCurSlide == Z.media.properties.playingInCurSlide && 0 !== Z.media.properties.playingInCurSlide && (Z.functions.setStates(Z.slideshow, {
                        pausedByVideo: !1
                    }), Z.slideshow.remainingSlideDuration = 1, Z.slideshow.start())), Z.media.set.dataAttribute(e, "not-playing"), Z.media.events.stop(e, t, i)
                },
                removeFromTimeline: function(e) {
                    Z.transitions._slideTimeline.kill(null, e.closest(".ls-in-out")[0]), Z.transitions._slideTimelineAlternate.kill(null, e.closest(".ls-in-out")[0])
                }
            },
            youtube: {
                defaults: {
                    autoplay: 0,
                    playsinline: 1,
                    wmode: "opaque",
                    html5: 1,
                    enablejsapi: 1,
                    version: 3,
                    rel: 0
                },
                init: function() {
                    var f = 0;
                    this.$medias = Z.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 e = ee(this).attr({
                                id: "ls-youtube-" + ++f,
                                allow: "accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture; fullscreen",
                                allowfullscreen: ""
                            }),
                            t = e.closest(".ls-layer");
                        t.data("hasBeenSet") || Z.layers.set.singleLayer(t);
                        var i, a, s, r, o, n, l, d, c = t.data(Z.defaults.init.dataKey),
                            u = e.attr("src") || e.attr("data-src"),
                            p = Z.media.functions.urlToObject(u),
                            h = (u = u.split("?")[0].split("//")[1]).split("/"),
                            m = h[h.length - 1],
                            h = Z.media.set.customPoster(t, c);
                        c.mediaProperties = {
                            type: "youtube",
                            $media: e,
                            embedURL: u,
                            embedID: m,
                            embedOptions: p
                        }, h ? (c.mediaProperties.poster = h, Z.media.set.properties(t, e, c)) : (i = ["default.jpg", "mqdefault.jpg", "hqdefault.jpg", "sddefault.jpg", "maxresdefault.jpg"], a = "https://img.youtube.com/vi/" + u.split("embed/")[1].split("?")[0] + "/", s = a + Z.o.youtubePreview, o = r = 0, n = function() {
                            this.width > r && (r = this.width, s = this.src), d()
                        }, l = function() {
                            d()
                        }, d = function() {
                            (o += 1) === i.length && (c.mediaProperties.poster = s, Z.media.set.properties(t, e, c))
                        }, i.forEach(function(e) {
                            var t = new Image;
                            t.addEventListener("error", l, !1), t.addEventListener("load", n, !1), t.src = a + e
                        }))
                    }), this.$medias.length && (Z.media.properties.$allMediaLayers = Z.media.properties.$allMediaLayers.add(this.$medias.closest(".ls-layer")), Z.timeouts.loadYouTube = Math.floor(Date.now() / 1e3), window.YT || ee("<script>").attr({
                        src: "https://www.youtube.com/iframe_api",
                        type: "text/javascript"
                    }).appendTo("head"), window.onYouTubeIframeAPIReady = function() {
                        window._layerSlider.globals.youTubeIsReady = !0
                    }, Z.intervals.isYouTubeReady = setInterval(function() {
                        window.YT && 1 === window.YT.loaded || window._layerSlider.globals.youTubeIsReady || 3 < Math.floor(Date.now() / 1e3) - Z.timeouts.loadYouTube ? (clearInterval(Z.intervals.isYouTubeReady), delete Z.intervals.isYouTubeReady, delete Z.timeouts.loadYouTube, Z.media.youtube.$medias.closest(".ls-layer").each(function() {
                            var e = ee(this),
                                t = e.data(Z.defaults.init.dataKey);
                            e.on("playMedia." + B + " click." + B, ".ls-vpcontainer", function() {
                                Z.media.set.thumbnail(ee(this), "hide"), Z.media.functions.checkSlideshowState(e, t), Z.media.functions.removeFromTimeline(e), Z.media.youtube.play(e, t.mediaProperties.$media, t, t.mediaProperties.embedURL)
                            }).on("playBackgroundVideo." + B, function() {
                                Z.media.youtube.play(e, t.mediaProperties.$media, t, t.mediaProperties.embedURL), Z.layers.set.dataAttribute(e, "active")
                            }).on("stopBackgroundVideo." + B, function() {
                                Z.media.youtube.stop(e, t.mediaProperties.$media, t, !0), Z.layers.set.dataAttribute(e, "hidden")
                            }).on("preloadBackgroundVideo." + B, function() {
                                Z.media.youtube.createPlayer(e, t.mediaProperties.$media, t, t.mediaProperties.embedURL, !0)
                            })
                        }), Z.functions.setStates(Z.slider, {
                            waitingForYouTube: !1
                        })) : Z.functions.setStates(Z.slider, {
                            waitingForYouTube: !0
                        })
                    }, 25))
                },
                createPlayer: function(t, i, a, s, r) {
                    a.mediaProperties.playerState = "initializing", "controls" in a.mediaSettings && (a.mediaProperties.options.controls = a.mediaSettings.controls ? 1 : 0), "loop" in a.mediaSettings && (a.mediaProperties.options.loop = a.mediaSettings.loop ? 1 : 0), "showinfo" in a.mediaSettings && (a.mediaProperties.options.showinfo = a.mediaSettings.showinfo ? 1 : 0), a.mediaProperties.options.loop ? a.mediaProperties.options.playlist = a.mediaProperties.embedID : delete a.mediaProperties.options.playlist, 0 === a.mediaProperties.options.showinfo && (a.mediaProperties.options.modestbranding = 1), i.attr("src", "https://" + s + "?" + jQuery.param(a.mediaProperties.options)).on("load", function() {
                        a.mediaProperties.player = new YT.Player(i[0], {
                            events: {
                                onReady: function(e) {
                                    a.mediaProperties.playerState = "ready", a.mediaSettings.volume && a.mediaProperties.player.setVolume(a.mediaSettings.volume), r && !a.mediaProperties.shouldPlay || (Z.media.youtube.play(t, i, a, s), a.mediaProperties.shouldPlay = !1)
                                },
                                onStateChange: function(e) {
                                    switch (e.data) {
                                        case 0:
                                            a.mediaProperties.options.loop && 1 === a.mediaProperties.options.loop || Z.media.functions.mediaEnded(i, t, a);
                                            break;
                                        case 1:
                                            Z.media.events.start(i, t, a), a.mediaProperties.lastStarted = Date.now();
                                            break;
                                        case 2:
                                        case -1:
                                            a.mediaProperties.firstState && 0 !== a.mediaProperties.lastState && 1 !== a.mediaProperties.lastState || a.mediaProperties.lastStarted && (Date.now(), a.mediaProperties.lastStarted)
                                    }
                                    1 === e.data ? Z.media.set.dataAttribute(i, "playing") : Z.media.set.dataAttribute(i, "not-playing"), Z.media.youtube.savePlayerState(a, e.data)
                                }
                            }
                        })
                    })
                },
                savePlayerState: function(e, t) {
                    e.mediaProperties.firstState || (e.mediaProperties.firstState = t), e.mediaProperties.lastState = t
                },
                play: function(e, t, i, a, s) {
                    void 0 !== t.attr("data-ls-muted-by-browser") && Z.media.unmute.singleMediaElement(t), i.mediaProperties.player ? i.mediaProperties.player.playVideo ? (!i.is.backgroundVideo || "muted" in i.mediaSettings || i.mediaProperties.player.mute(), i.mediaSettings.muted ? Z.o.rememberUnmuteState && Z.media.properties.userDidUnmute || (i.mediaProperties.player.mute(), "offertounmute" == i.mediaSettings.muted && Z.media.unmute.set(t, i.mediaProperties.type)) : s && (i.mediaProperties.player.mute(), Z.media.unmute.set(t, i.mediaProperties.type, !0)), Z.media.functions.allowedToPlay(t, i) ? i.mediaProperties.player.playVideo() : Z.media.youtube.stop(e, t, i, !0)) : i.mediaProperties.shouldPlay = !0 : i.mediaProperties.playerState ? i.mediaProperties.shouldPlay = !0 : this.createPlayer(e, t, i, a)
                },
                stop: function(e, t, i, a) {
                    i.mediaProperties.player && (i.mediaProperties.player.pauseVideo(), a && i.mediaProperties.player.seekTo(0), i.is.backgroundVideo || Z.media.set.thumbnail(e.find(".ls-vpcontainer"), "show"), Z.media.events.stop(t, e, i))
                }
            },
            vimeo: {
                defaults: {
                    autoplay: 0,
                    autopause: 0,
                    wmode: "opaque",
                    playsinline: 1
                },
                init: function() {
                    var d, e, t = this.$medias = Z.slider.$hiddenWrapper.find('iframe[src*="player.vimeo"], iframe[data-src*="player.vimeo"]'),
                        c = Z.slider.$hiddenWrapper.find('.ls-slide:eq(0) iframe[src*="player.vimeo"], .ls-slide:eq(0) iframe[data-src*="player.vimeo"]').length;
                    t.length && (Z.timeouts.loadVimeo = Math.floor(Date.now() / 1e3), Z.media.properties.$allMediaLayers = Z.media.properties.$allMediaLayers.add(t.closest(".ls-layer")), d = 0, ee("<script>").attr({
                        src: "https://player.vimeo.com/api/player.js",
                        type: "text/javascript"
                    }).appendTo("head"), Z.intervals.isVimeoReady = setInterval(function() {
                        Z.functions.setStates(Z.slider, {
                            waitingForVimeo: !0
                        }), (window.Vimeo || 3 < Math.floor(Date.now() / 1e3) - Z.timeouts.loadVimeo) && (clearInterval(Z.intervals.isVimeoReady), delete Z.intervals.isVimeoReady, delete Z.timeouts.loadVimeo, e())
                    }, 25), e = function() {
                        var l = 0;
                        Z.media.vimeo.$medias.each(function() {
                            var t = ee(this).attr({
                                    id: "ls-vimeo-" + ++d,
                                    allow: "accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture; fullscreen",
                                    allowfullscreen: ""
                                }),
                                i = t.closest(".ls-layer");
                            i.data("hasBeenSet") || Z.layers.set.singleLayer(i);
                            var a = i.data(Z.defaults.init.dataKey),
                                e = t.attr("src") || t.attr("data-src"),
                                s = Z.media.functions.urlToObject(e),
                                r = "https://vimeo.com/api/oembed.json?url=http://vimeo.com/" + e.split("video/")[1].split("?")[0],
                                e = e.split("?")[0].split("//")[1];
                            Z.media.vimeo.defaults.player_id = "ls-vimeo-" + d;
                            var o = Z.media.set.customPoster(i, a);
                            a.mediaProperties = {
                                type: "vimeo",
                                $media: t,
                                embedURL: e,
                                embedOptions: s
                            };

                            function n(e) {
                                a.mediaProperties.poster = e, (0 === c || 0 < c && ++l == c) && (window._layerSlider.globals.vimeoIsReady = !0), Z.media.set.properties(i, t, a)
                            }
                            o ? n(o) : ee.getJSON(r, function(e) {
                                n(e.thumbnail_url)
                            }), i.on("playMedia." + B + " click." + B, ".ls-vpcontainer", function() {
                                Z.media.set.thumbnail(ee(this), "hide"), Z.media.functions.checkSlideshowState(i, a), Z.media.functions.removeFromTimeline(i), Z.media.vimeo.play(i, t, a, e)
                            }).on("playBackgroundVideo." + B, function() {
                                Z.media.vimeo.play(i, t, a, e), Z.layers.set.dataAttribute(i, "active")
                            }).on("stopBackgroundVideo." + B, function() {
                                Z.media.vimeo.stop(i, t, a, !0), Z.layers.set.dataAttribute(i, "hidden")
                            }).on("preloadBackgroundVideo." + B, function() {
                                Z.media.vimeo.createPlayer(i, t, a, e, !0)
                            })
                        }), Z.functions.setStates(Z.slider, {
                            waitingForVimeo: !1
                        })
                    })
                },
                createPlayer: function(e, t, i, a, s) {
                    i.mediaProperties.playerState = "initializing";
                    "controls" in i.mediaSettings && delete i.mediaSettings.controls, "loop" in i.mediaSettings && (i.mediaProperties.options.loop = i.mediaSettings.loop ? 1 : 0), "showinfo" in i.mediaSettings && (i.mediaSettings.showinfo ? (i.mediaProperties.options.byline = 1, i.mediaProperties.options.portrait = 1, i.mediaProperties.options.title = 1) : (i.mediaProperties.options.byline = 0, i.mediaProperties.options.portrait = 0, i.mediaProperties.options.title = 0), delete i.mediaProperties.options.showinfo), "volume" in i.mediaSettings && (0 === i.mediaSettings.volume ? (i.mediaSettings.volume = 100, i.mediaSettings.muted = 1) : (i.mediaSettings.volume < 0 || 100 < i.mediaSettings.volume) && (i.mediaSettings.volume = 100)), t.attr("src", "https://" + a + "?" + jQuery.param(i.mediaProperties.options)), i.mediaProperties.player = new Vimeo.Player(t[0]), i.mediaProperties.player.on("play", function() {
                        Z.media.set.dataAttribute(t, "playing"), Z.media.events.start(t, e, i)
                    }), i.mediaProperties.player.on("pause", function() {
                        Z.media.set.dataAttribute(t, "not-playing")
                    }), i.mediaProperties.player.on("ended", function() {
                        Z.media.functions.mediaEnded(t, e, i)
                    }), i.mediaProperties.player.ready().then(function() {
                        i.mediaProperties.playerState = "ready", i.mediaSettings.volume && !i.mediaSettings.muted && ee.isNumeric(i.mediaSettings.volume) && 0 <= i.mediaSettings.volume && i.mediaSettings.volume <= 100 && i.mediaProperties.player.setVolume(i.mediaSettings.volume / 100), s || Z.media.vimeo.play(e, t, i, a)
                    })
                },
                play: function(t, i, a, s, e) {
                    void 0 !== i.attr("data-ls-muted-by-browser") && Z.media.unmute.singleMediaElement(i), a.mediaProperties.player ? (!a.is.backgroundVideo || "muted" in a.mediaSettings || a.mediaProperties.player.setVolume(0), a.mediaSettings.muted && (Z.o.rememberUnmuteState && Z.media.properties.userDidUnmute ? Z.o.rememberUnmuteState && Z.media.properties.userDidUnmute && (a.mediaProperties.player.setVolume(a.mediaSettings.volume / 100 || 1), delete a.mediaSettings.muted) : (a.mediaProperties.player.setVolume(0), "offertounmute" == a.mediaSettings.muted && Z.media.unmute.set(i, a.mediaProperties.type))), e ? (a.mediaProperties.player.setVolume(0), Z.media.unmute.set(i, a.mediaProperties.type, !0)) : a.mediaProperties.player.getVolume().then(function(e) {
                        0 == e && "offertounmute" == a.mediaSettings.muted && Z.media.unmute.set(i, a.mediaProperties.type)
                    }), Z.media.functions.allowedToPlay(i, a) ? a.mediaProperties.player.play().then(function() {}).catch(function(e) {
                        switch (e.name) {
                            case "PasswordError":
                                window.console && (console.error(Z.defaults.slider.errorText), console.error("Vimeo video is password protected and may cause playback issues."));
                                break;
                            case "PrivacyError":
                                window.console && (console.error(Z.defaults.slider.errorText), console.error("Vimeo video is private and may cause playback issues."));
                                break;
                            default:
                                Z.media.vimeo.play(t, i, a, s, !0)
                        }
                    }) : Z.media.vimeo.stop(t, i, a, !0)) : this.createPlayer(t, i, a, s)
                },
                stop: function(e, t, i, a) {
                    i.mediaProperties.player && (i.mediaProperties.player.pause(), a && i.mediaProperties.player.setCurrentTime(0), i.is.backgroundVideo || Z.media.set.thumbnail(e.find(".ls-vpcontainer"), "show"), Z.media.events.stop(t, e, i))
                }
            },
            html5: {
                singleInit: function(t) {
                    var e, i, a, s, r = t.closest(".ls-layer"),
                        o = r.data(Z.defaults.init.dataKey),
                        n = t.find("source"),
                        l = Z.media.set.customPoster(r, o);
                    o.mediaProperties = {
                        type: "html5",
                        $media: t,
                        poster: l || t.attr("poster")
                    }, t.removeAttr("poster"), 0 < n.length ? n.each(function() {
                        void 0 !== (e = ee(this).attr("type")) && !1 !== e || (i = ee(this).attr("src"), a = i.split("."), s = a[a.length - 1].toLowerCase(), ee(this).attr("type", ee(this).parent()[0].tagName.toLowerCase() + "/" + s)), "" !== t[0].canPlayType(ee(this).attr("type")) && (o.mediaProperties.canBePlayed = !0)
                    }) : void 0 !== t.attr("src") && !1 !== t.attr("src") && (i = t.attr("src"), a = i.split("."), s = a[a.length - 1].toLowerCase(), "" !== t[0].canPlayType(t[0].tagName.toLowerCase() + "/" + s) && (o.mediaProperties.canBePlayed = !0)), o.mediaProperties.canBePlayed && (Z.media.set.properties(r, t, o), t.on("ended." + B, function() {
                        Z.media.functions.mediaEnded(t, r, o)
                    }).on("play." + B, function() {}).on("playing." + B, function() {
                        Z.media.events.start(t, r, o), Z.media.set.dataAttribute(t, "playing")
                    }).on("pause." + B, function() {
                        Z.media.set.dataAttribute(t, "not-playing")
                    }), r.on("playMedia." + B + " click." + B, ".ls-vpcontainer", function(e) {
                        Z.media.set.thumbnail(ee(this), "hide"), Z.media.functions.checkSlideshowState(r, o), Z.media.functions.removeFromTimeline(r), Z.media.html5.play(r, t, o)
                    }).on("playBackgroundVideo." + B, function() {
                        Z.media.html5.play(r, t, o), Z.layers.set.dataAttribute(r, "active")
                    }).on("stopBackgroundVideo." + B, function() {
                        Z.media.html5.stop(r, t, o, !0), Z.layers.set.dataAttribute(r, "hidden")
                    }))
                },
                init: function() {
                    var e, t = Z.slider.$hiddenWrapper.find("video, audio");
                    Z.media.properties.$allMediaLayers = Z.media.properties.$allMediaLayers.add(t.closest(".ls-layer")), t.length && (e = 0, t.each(function() {
                        ee(this).closest(".ls-layer").data(Z.defaults.init.dataKey).is.mediaLayer = !0, ee(this).attr("id", "ls-html5-" + ++e).attr("playsinline", ""), ee(this)[0].pause()
                    }))
                },
                play: function(e, t, i) {
                    var a;
                    i.mediaProperties.canBePlayed && (void 0 !== t.attr("data-ls-muted-by-browser") && Z.media.unmute.singleMediaElement(t), i.mediaSettings.muted && (Z.o.rememberUnmuteState && Z.media.properties.userDidUnmute ? Z.o.rememberUnmuteState && Z.media.properties.userDidUnmute && (t[0].muted = !1) : (t[0].muted = !0, "offertounmute" == i.mediaSettings.muted && Z.media.unmute.set(t, i.mediaProperties.type))), void 0 !== (a = t[0].play()) && a.then(function(e) {}).catch(function(e) {
                        t[0].muted = !0, t[0].play(), t[0].paused && Z.functions.setStates(Z.slideshow, {
                            pausedByVideo: !1
                        }), Z.media.unmute.set(t, i.mediaProperties.type, !0)
                    }))
                },
                stop: function(e, t, i, a) {
                    i.mediaProperties.canBePlayed && (t[0].pause(), a && (t[0].currentTime = 0), i.is.backgroundVideo || Z.media.set.thumbnail(ee(this), "show"), Z.media.events.stop(t, e, i))
                }
            }
        }, Z.yourLogo = {
            init: function() {
                Z.o.yourLogo && (this.$element = ee("<img>").addClass("ls-yourlogo").appendTo($).attr("style", Z.o.yourLogoStyle).css({
                    visibility: "hidden",
                    display: "bock"
                }).on("load." + B, function() {
                    var e = Z.yourLogo.$element ? 500 : 0;
                    Z.timeouts.yourLogo = setTimeout(function() {
                        delete Z.timeouts.yourLogo, Z.yourLogo.$element.data("originalWidth", Z.yourLogo.$element.width()), Z.yourLogo.$element.data("originalHeight", Z.yourLogo.$element.height()), "auto" != Z.yourLogo.$element.css("left") && Z.yourLogo.$element.data("originalLeft", Z.yourLogo.$element[0].style.left), "auto" != Z.yourLogo.$element.css("right") && Z.yourLogo.$element.data("originalRight", Z.yourLogo.$element[0].style.right), "auto" != Z.yourLogo.$element.css("top") && Z.yourLogo.$element.data("originalTop", Z.yourLogo.$element[0].style.top), "auto" != Z.yourLogo.$element.css("bottom") && Z.yourLogo.$element.data("originalBottom", Z.yourLogo.$element[0].style.bottom), !1 !== Z.o.yourLogoLink && ee("<a>").appendTo($).attr("href", Z.o.yourLogoLink).attr("target", Z.o.yourLogoTarget).css({
                            textDecoration: "none",
                            outline: "none"
                        }).append(Z.yourLogo.$element), Z.yourLogo.$element.css({
                            display: "none",
                            visibility: "visible"
                        }), Z.yourLogo.resize()
                    }, e)
                }).attr("src", Z.o.yourLogo))
            },
            resize: function() {
                this.$element.css({
                    width: this.$element.data("originalWidth") * Z.resize.ratio,
                    height: this.$element.data("originalHeight") * Z.resize.ratio
                }), this.$element.fadeIn(300);
                var e = "auto",
                    t = "auto",
                    i = "auto",
                    a = "auto",
                    e = this.$element.data("originalLeft") && -1 != this.$element.data("originalLeft").indexOf("%") ? $.width() / 100 * parseFloat(this.$element.data("originalLeft")) - this.$element.width() / 2 + parseInt($.css("padding-left")) : parseInt(this.$element.data("originalLeft")) * Z.resize.ratio,
                    t = this.$element.data("originalRight") && -1 != this.$element.data("originalRight").indexOf("%") ? $.width() / 100 * parseFloat(this.$element.data("originalRight")) - this.$element.width() / 2 + parseInt($.css("padding-right")) : parseInt(this.$element.data("originalRight")) * Z.resize.ratio,
                    i = this.$element.data("originalTop") && -1 != this.$element.data("originalTop").indexOf("%") ? $.height() / 100 * parseFloat(this.$element.data("originalTop")) - this.$element.height() / 2 + parseInt($.css("padding-top")) : parseInt(this.$element.data("originalTop")) * Z.resize.ratio,
                    a = this.$element.data("originalBottom") && -1 != this.$element.data("originalBottom").indexOf("%") ? $.height() / 100 * parseFloat(this.$element.data("originalBottom")) - this.$element.height() / 2 + parseInt($.css("padding-bottom")) : parseInt(this.$element.data("originalBottom")) * Z.resize.ratio;
                this.$element.css({
                    left: e,
                    right: t,
                    top: i,
                    bottom: a
                })
            }
        }, Z.gui = {
            navigation: {
                init: function() {
                    Z.o.navPrevNext && this.prevNext.init(), (Z.o.navStartStop || Z.o.navButtons) && this.bottom.init()
                },
                prevNext: {
                    init: function() {
                        ee('<a class="ls-gui-element ls-nav-prev" aria-label="jump to the previous slide" href="#" />').on("click." + B, function(e) {
                            e.preventDefault(), $.layerSlider("prev")
                        }).appendTo($), ee('<a class="ls-gui-element ls-nav-next" aria-label="jump to the next slide" href="#" />').on("click." + B, function(e) {
                            e.preventDefault(), $.layerSlider("next")
                        }).appendTo($), Z.o.hoverPrevNext && this.setHover()
                    },
                    setHover: function() {
                        $.find(".ls-nav-prev, .ls-nav-next").css({
                            display: "none"
                        }), $.on("mouseenter." + B, function() {
                            Z.gui.navigation.forceHide || $.find(".ls-nav-prev, .ls-nav-next").stop(!0, !0).fadeIn(300)
                        }).on("mouseleave." + B, function() {
                            $.find(".ls-nav-prev, .ls-nav-next").stop(!0, !0).fadeOut(300)
                        })
                    }
                },
                bottom: {
                    init: function() {
                        this.wrapper = ee('<div class="ls-gui-element ls-bottom-nav-wrapper" />').appendTo($), Z.o.navButtons && "always" != Z.o.thumbnailNavigation && this.bullets.init(), Z.o.navStartStop ? this.createStartStop() : "always" != Z.o.thumbnailNavigation && this.createSides(), Z.o.hoverBottomNav && "always" != Z.o.thumbnailNavigation && this.setHover(), "always" == Z.o.thumbnailNavigation && (this.wrapper.addClass("ls-above-thumbnails"), this.thumbnails.init())
                    },
                    bullets: {
                        init: function() {
                            var t = this;
                            ee('<span class="ls-bottom-slidebuttons" />').appendTo($.find(".ls-bottom-nav-wrapper"));
                            for (var e = 0; e < Z.slides.count; e++) {
                                var i = ee('<a href="#" aria-label="jump to slide ' + (e + 1) + '" />').appendTo($.find(".ls-bottom-slidebuttons")).data("index", e + 1).on("click." + B, function(e) {
                                    e.preventDefault(), $.layerSlider(ee(this).data("index"))
                                });
                                "hover" == Z.o.thumbnailNavigation && i.on("mouseenter." + B, function() {
                                    var e = ee(this);
                                    $.find(".ls-thumbnail-hover-img").css({
                                        left: parseInt(t.hoverWrapper.css("padding-left")),
                                        top: parseInt(t.hoverWrapper.css("padding-top"))
                                    }), t.hoverImage.on("load." + B, function() {
                                        0 === ee(this).width() ? t.hoverImage.css({
                                            position: "relative",
                                            margin: "0 auto",
                                            left: "auto"
                                        }) : t.hoverImage.css({
                                            position: "absolute",
                                            marginLeft: -ee(this).width() / 2,
                                            left: "50%"
                                        }), t.hoverImage.css("display", "none").stop(!0, !0).fadeIn(250)
                                    }).attr("src", Z.slides[e.data("index")].data.thumbnail), t.hoverWrapper.css({
                                        display: "block"
                                    }).stop().animate({
                                        left: ee(this).position().left + (ee(this).width() - t.hoverWrapper.outerWidth()) / 2
                                    }, 250), t.hoverWrapperInner.css({
                                        display: "none",
                                        visibility: "visible"
                                    }).stop().fadeIn(250)
                                }).on("mouseleave." + B, function() {
                                    t.hoverWrapperInner.stop().fadeOut(250, function() {
                                        t.hoverWrapper.css({
                                            visibility: "hidden",
                                            display: "block"
                                        })
                                    })
                                })
                            }
                            t.set.active(Z.slides.first.index), "hover" == Z.o.thumbnailNavigation && t.set.hover()
                        },
                        set: {
                            active: function(e) {
                                void 0 === e && (e = Z.slides.current.index), e--, $.find(".ls-bottom-slidebuttons a").removeClass("ls-nav-active"), $.find(".ls-bottom-slidebuttons a:eq( " + e + " )").addClass("ls-nav-active")
                            },
                            hover: function() {
                                var e = Z.gui.navigation.bottom.bullets,
                                    t = ee('<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($.find(".ls-bottom-slidebuttons"));
                                $.find(".ls-thumbnail-hover, .ls-thumbnail-hover-img").css({
                                    width: Z.o.tnWidth,
                                    height: Z.o.tnHeight
                                }), e.hoverWrapper = $.find(".ls-thumbnail-hover"), e.hoverImage = e.hoverWrapper.find("img").css({
                                    height: Z.o.tnHeight
                                }), e.hoverWrapperInner = $.find(".ls-thumbnail-hover-inner").css({
                                    visibility: "hidden",
                                    display: "block"
                                }), t.appendTo($.find(".ls-bottom-slidebuttons"))
                            }
                        }
                    },
                    createStartStop: function() {
                        this.buttonStart = ee('<a class="ls-nav-start" aria-label="start slideshow" href="#" />').on("click." + B, function(e) {
                            e.preventDefault(), $.layerSlider("start")
                        }).prependTo($.find(".ls-bottom-nav-wrapper")), this.buttonStop = ee('<a class="ls-nav-stop" aria-label="stop slideshow" href="#" />').on("click." + B, function(e) {
                            e.preventDefault(), $.layerSlider("stop")
                        }).appendTo($.find(".ls-bottom-nav-wrapper")), Z.o.autoStart ? this.setStartStop("start") : this.setStartStop("stop")
                    },
                    setStartStop: function(e) {
                        if (Z.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() {
                        ee('<span class="ls-nav-sides ls-nav-sideleft" />').prependTo($.find(".ls-bottom-nav-wrapper")), ee('<span class="ls-nav-sides ls-nav-sideright" />').appendTo($.find(".ls-bottom-nav-wrapper"))
                    },
                    setHover: function() {
                        var e = this;
                        e.wrapper.css({
                            display: "none"
                        }), $.on("mouseenter." + B, function() {
                            Z.gui.navigation.forceHide || e.wrapper.stop(!0, !0).fadeIn(300)
                        }).on("mouseleave." + B, function() {
                            e.wrapper.stop(!0, !0).fadeOut(300)
                        })
                    },
                    switchHelper: function(e) {
                        if (Z.o.hoverBottomNav && !$.hasClass("ls-hover")) switch (e) {
                            case "on":
                                Z.gui.navigation.bottom.thumbnails.wrapper.css({
                                    visibility: "hidden",
                                    display: "block"
                                });
                                break;
                            case "off":
                                Z.gui.navigation.bottom.thumbnails.wrapper.css({
                                    visibility: "visible",
                                    display: "none"
                                })
                        }
                    },
                    thumbnails: {
                        init: function() {
                            this.wrapper = ee('<div class="ls-gui-element ls-thumbnail-wrapper"></div>').appendTo($), ee('<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 = $.find(".ls-thumbnail-slide-container"), "ontouchstart" in window ? this.$element.addClass("ls-touchscroll") : this.$element.on("mouseenter." + B, function() {
                                ee(this).addClass("ls-thumbnail-slide-hover")
                            }).on("mouseleave." + B, function() {
                                ee(this).removeClass("ls-thumbnail-slide-hover"), Z.gui.navigation.bottom.thumbnails.scroll()
                            }).on("mousemove." + B, function(e) {
                                e = parseInt(e.pageX - ee(this).offset().left) / ee(this).width() * (ee(this).width() - ee(this).find(".ls-thumbnail-slide").width());
                                ee(this).find(".ls-thumbnail-slide").stop().css({
                                    marginLeft: e
                                })
                            });
                            for (var e = 0; e < Z.slides.count; e++) {
                                var t = e + 1,
                                    i = ee('<a href="#" class="ls-thumb-' + (e + 1) + '"  aria-label="jump to slide ' + (e + 1) + '"><img src="' + Z.slides[t].data.thumbnail + '"></a>');
                                Z.slides[t].data.tnAlt && i.find("img").attr("alt", Z.slides[t].data.tnAlt), i.data("index", t).on("click." + B, function(e) {
                                    e.preventDefault(), $.layerSlider(ee(this).data("index"))
                                }).appendTo($.find(".ls-thumbnail-slide")), "ontouchstart" in window || i.on("mouseenter." + B, function() {
                                    ee(this).children().stop().fadeTo(300, Z.o.tnActiveOpacity / 100)
                                }).on("mouseleave." + B, function() {
                                    ee(this).children().hasClass("ls-thumb-active") || ee(this).children().stop().fadeTo(300, Z.o.tnInactiveOpacity / 100)
                                })
                            }
                            Z.gui.navigation.bottom.buttonStart && Z.gui.navigation.bottom.buttonStop && (Z.gui.navigation.bottom.wrapper = ee('<div class="ls-bottom-nav-wrapper ls-below-thumbnails"></div>').appendTo($), Z.gui.navigation.bottom.buttonStart.clone().on("click." + B, function(e) {
                                e.preventDefault(), $.layerSlider("start")
                            }).appendTo(Z.gui.navigation.bottom.wrapper), Z.gui.navigation.bottom.buttonStop.clone().on("click." + B, function(e) {
                                e.preventDefault(), $.layerSlider("stop")
                            }).appendTo(Z.gui.navigation.bottom.wrapper)), Z.o.hoverBottomNav && this.setHover()
                        },
                        setHover: function() {
                            var e = this;
                            e.wrapper.css("display", "none"), Z.gui.navigation.bottom.wrapper && (Z.gui.navigation.bottom.wrapper = "block" == Z.gui.navigation.bottom.wrapper.css("display") ? Z.gui.navigation.bottom.wrapper : $.find(".ls-above-thumbnails"), Z.gui.navigation.bottom.wrapper.css("display", "none")), $.on("mouseenter." + B, function() {
                                $.addClass("ls-hover"), Z.gui.navigation.forceHide || (e.wrapper.stop(!0, !0).fadeIn(300), Z.gui.navigation.bottom.wrapper && Z.gui.navigation.bottom.wrapper.stop(!0, !0).fadeIn(300))
                            }).on("mouseleave." + B, function() {
                                $.removeClass("ls-hover"), e.wrapper.stop(!0, !0).fadeOut(300), Z.gui.navigation.bottom.wrapper && Z.gui.navigation.bottom.wrapper.stop(!0, !0).fadeOut(300)
                            })
                        },
                        change: function(e) {
                            e = e || Z.slides.next.index;
                            $.find(".ls-thumbnail-slide a:not(.ls-thumb-" + e + " )").children().each(function() {
                                ee(this).removeClass("ls-thumb-active").stop().fadeTo(750, Z.o.tnInactiveOpacity / 100)
                            }), $.find(".ls-thumbnail-slide a.ls-thumb-" + e).children().addClass("ls-thumb-active").stop().fadeTo(750, Z.o.tnActiveOpacity / 100)
                        },
                        scroll: function() {
                            var e;
                            $.find(".ls-thumbnail-slide-container").hasClass("ls-thumbnail-slide-hover") || (e = !!$.find(".ls-thumb-active").length && $.find(".ls-thumb-active").parent()) && (e = e.position().left + e.width() / 2, e = 0 < (e = (e = $.find(".ls-thumbnail-slide-container").width() / 2 - e) < $.find(".ls-thumbnail-slide-container").width() - $.find(".ls-thumbnail-slide").width() ? $.find(".ls-thumbnail-slide-container").width() - $.find(".ls-thumbnail-slide").width() : e) ? 0 : e, $.find(".ls-thumbnail-slide").animate({
                                marginLeft: e
                            }, 600))
                        },
                        resize: function() {
                            Z.gui.navigation.bottom.switchHelper("on");
                            var e = -1 == Z.slider.initial.width.indexOf("%") ? parseInt(Z.slider.initial.originalWidth) : $.width(),
                                t = $.find(".ls-thumbnail"),
                                e = -1 == Z.o.tnContainerWidth.indexOf("%") ? parseInt(Z.o.tnContainerWidth) : parseInt(e / 100 * parseInt(Z.o.tnContainerWidth));
                            $.find(".ls-thumbnail-slide a").css({
                                width: parseInt(Z.o.tnWidth * Z.resize.ratio),
                                height: parseInt(Z.o.tnHeight * Z.resize.ratio)
                            }), $.find(".ls-thumbnail-slide a:last").css({
                                margin: 0
                            }), $.find(".ls-thumbnail-slide").css({
                                height: parseInt(Z.o.tnHeight * Z.resize.ratio)
                            }), t.css({
                                width: e * Math.floor(100 * Z.resize.ratio) / 100
                            }), t.width() > $.find(".ls-thumbnail-slide").width() && t.css({
                                width: $.find(".ls-thumbnail-slide").width()
                            }), Z.gui.navigation.bottom.switchHelper("off")
                        }
                    }
                }
            },
            media: {
                init: function() {
                    0 < Z.media.properties.$allMediaLayers.length && ee('<div class="ls-gui-element ls-media-unmute" aria-label="Unmute"><div class="ls-media-unmute-bg"></div><div class="ls-icon-muted"></div><div class="ls-icon-unmuted"></div></div>').on("click." + B, function(e) {
                        e.preventDefault(), $.layerSlider("unmute")
                    }).appendTo($)
                },
                showUnmute: function() {
                    $.find(".ls-media-unmute").addClass("ls-media-unmute-active")
                },
                hideUnmute: function() {
                    $.find(".ls-media-unmute").removeClass("ls-media-unmute-active")
                }
            },
            skin: {
                load: function() {
                    $.addClass("ls-" + Z.o.skin);
                    var e, t = Z.o.skinsPath + Z.o.skin + "/skin.css",
                        i = ee("head").length ? ee("head") : ee("body");
                    ee('link[href="' + t + '"]').length ? (e = ee('link[href="' + t + '"]'), Z.gui.skin.isLoaded || (Z.gui.skin.isLoaded = !0, Z.timeouts.skinLoad1 = setTimeout(function() {
                        delete Z.timeouts.skinLoad1, Z.slider.init()
                    }, 150))) : e = document.createStyleSheet ? (document.createStyleSheet(t), ee('link[href="' + t + '"]')) : ee('<link rel="stylesheet" href="' + t + '" type="text/css" />').appendTo(i), e.on("load." + B, function() {
                        Z.gui.skin.isLoaded || (Z.gui.skin.isLoaded = !0, Z.timeouts.skinLoad2 = setTimeout(function() {
                            delete Z.timeouts.skinLoad2, Z.slider.init()
                        }, 150))
                    }), ee(window).on("load." + B, function() {
                        Z.gui.skin.isLoaded || (Z.gui.skin.isLoaded = !0, Z.timeouts.skinLoad3 = setTimeout(function() {
                            delete Z.timeouts.skinLoad3, Z.slider.init()
                        }, 150))
                    }), Z.timeouts.skinLoad4 = setTimeout(function() {
                        Z.gui.skin.isLoaded || (Z.gui.skin.isLoaded = !0, delete Z.timeouts.skinLoad4, Z.slider.init())
                    }, 1e3)
                }
            },
            shadow: {
                init: function() {
                    this.set(), this.resize()
                },
                set: function() {
                    this.$element = ee('<div class="ls-gui-element ls-shadow"></div>').appendTo($), "block" != this.$element.css("display") || this.$element.find("img").length || (this.show = function() {
                        Z.gui.shadow.$element.css({
                            display: "none",
                            visibility: "visible"
                        }).fadeIn(500, function() {
                            Z.gui.shadow.show = !1
                        })
                    }, this.image = ee("<img>").attr("src", Z.o.skinsPath + Z.o.skin + "/shadow.png").appendTo(this.$element), this.btmMod = "number" == typeof parseInt($.css("padding-bottom")) ? parseInt($.css("padding-bottom")) : 0)
                },
                resize: function() {
                    this.image && (0 < this.image.height() ? 0 < this.btmMod ? this.$element.css({
                        height: this.image.height() / 2
                    }) : this.$element.css({
                        height: this.image.height(),
                        marginTop: -this.image.height() / 2
                    }) : Z.timeouts.resizeShadow = setTimeout(function() {
                        delete Z.timeouts.resizeShadow, Z.gui.shadow.resize()
                    }, 50))
                }
            },
            timers: {
                init: function() {
                    Z.o.showBarTimer && this.bar.create(), Z.o.showCircleTimer && this.circle.create();
                    var e = !1;
                    (e = Z.o.showSlideBarTimer ? ee("<div>").insertAfter($) : ee('[data-slidebar-for="' + $.attr("id") + '"], [data-slidebar-for="' + B + '"]')).length && (e.addClass("ls-gui-element"), this.slidebar.create(e))
                },
                bar: {
                    create: function() {
                        this.$element = ee("<div>").addClass("ls-gui-element ls-bar-timer").appendTo($)
                    }
                },
                circle: {
                    create: function() {
                        this.$element = ee("<div>").addClass("ls-gui-element ls-circle-timer").appendTo($), this.$element.append(ee('<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: [],
                    state: {},
                    create: function(e) {
                        function i(e, t) {
                            (s = (e.pageX || Z.device.touchX || 0) - o.$element[t].offset().left - o.sliderContainerElementWidth[t] / 2) < 0 && (s = 0), s > o.containerElementWidth[t] - o.sliderContainerElementWidth[t] && (s = "calc( 100% - " + Z.gui.timers.slidebar.sliderContainerElementWidth[t] + "px )"), o.$sliderContainerElement[t].css({
                                left: s
                            }), Z.transitions._slideTimeline && Z.transitions._slideTimeline.progress("string" == typeof s ? Z.transitions.layers.timeline.progress : s / (o.containerElementWidth[t] - o.sliderContainerElementWidth[t]) * Z.transitions.layers.timeline.progress)
                        }

                        function a(e) {
                            "dragging" == Z.gui.timers.slidebar.state && (Z.transitions._slideTimeline && Z.transitions.layers.timeline.state.finished && Z.transitions._slideTimeline.progress() !== Z.transitions.layers.timeline.progress && Z.functions.setStates(Z.transitions.layers.timeline, {
                                finished: !1
                            }), ee(document).off("mousemove." + B), ee("body").prop("unselectable", !1).removeClass("ls-unselectable"), Z.o.pauseLayers && !Z.slideshow.state.running || Z.slider.state.isPaused || !Z.transitions._slideTimeline || Z.o.playByScroll || (!0 === Z.transitions.layers.timeline.state.started ? Z.transitions.layers.timeline.resume() : Z.transitions.layers.timeline.play()), Z.gui.timers.slidebar.state = !1)
                        }
                        var s, r = ee(document),
                            o = this;
                        ee.each(e, function(t, e) {
                            o.$containerElement[t] = ee(e).addClass("ls-slidebar-container " + B), o.$element[t] = ee("<div>").addClass("ls-slidebar").appendTo(o.$containerElement[t]), o.$progressBarElement[t] = ee("<div>").addClass("ls-progressbar").appendTo(o.$element[t]), o.$sliderContainerElement[t] = ee("<div>").addClass("ls-slidebar-slider-container").appendTo(o.$containerElement[t]), o.$sliderElement[t] = ee("<div>").addClass("ls-slidebar-slider").appendTo(o.$sliderContainerElement[t]), o.sliderContainerElementWidth[t] = o.$sliderContainerElement[t].width(), o.$sliderContainerElement[t].css({
                                marginTop: -o.$sliderElement[t].outerHeight() / 2
                            }), o.$containerElement[t].on("touchmove." + B, function(e) {
                                i(e, t)
                            }), o.$containerElement[t].on("touchend." + B, function(e) {
                                a()
                            }), o.$containerElement[t].on("mousedown." + B + " touchstart." + B, function(e) {
                                Z.transitions.layers.timeline.pause(0), ee("body").prop("unselectable", !0).addClass("ls-unselectable"), ee(document).on("mousemove." + B, function(e) {
                                    i(e, t)
                                }), i(e, t), Z.gui.timers.slidebar.state = "dragging"
                            }), r = r.add(o.$sliderElement[t])
                        }), ee("body").on("mouseup." + B, function(e) {
                            a()
                        })
                    }
                }
            },
            loadingIndicator: {
                init: function() {
                    this.$element = ee("<div>").css({
                        display: "none"
                    }).addClass("ls-gui-element ls-loading-container").appendTo($), ee("<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)
                }
            }
        }, Z.navigation = {
            direction: "next",
            init: function() {
                1 < Z.slides.count && (this.set.keyboard(), this.set.touch())
            },
            set: {
                keyboard: function() {
                    Z.o.keybNav && ee("body").on("keydown." + B, function(e) {
                        ee(e.target).is(":input") || Z.slider.isAnimating || Z.slider.isPreloading || (37 == e.which ? Z.navigation.prev() : 39 == e.which && Z.navigation.next())
                    })
                },
                touch: function() {
                    "ontouchstart" in window && Z.o.touchNav && (Z.slider.$innerWrapper.on("touchstart." + B, function(e) {
                        e = e.touches || e.originalEvent.touches;
                        1 == e.length && (Z.device.touchStartX = Z.device.touchEndX = e[0].clientX)
                    }), Z.slider.$innerWrapper.on("touchmove." + B, function(e) {
                        var t = e.touches || e.originalEvent.touches;
                        1 == t.length && (Z.device.touchEndX = t[0].clientX), 45 < Math.abs(Z.device.touchStartX - Z.device.touchEndX) && e.preventDefault()
                    }), Z.slider.$innerWrapper.on("touchend." + B, function(e) {
                        45 < Math.abs(Z.device.touchStartX - Z.device.touchEndX) && (0 < Z.device.touchStartX - Z.device.touchEndX ? $.layerSlider("touchNext") : $.layerSlider("touchPrev"))
                    }))
                }
            },
            prev: function() {
                (!Z.slider.isPopup || Z.slider.isPopup && Z.slider.state.popupIsVisible) && (this.direction = "prev", this.forceDirection = "prev", Z.slideshow.set.prevNext("prev"))
            },
            next: function() {
                (!Z.slider.isPopup || Z.slider.isPopup && Z.slider.state.popupIsVisible) && (this.direction = "next", this.forceDirection = "next", Z.slideshow.set.prevNext("next"))
            },
            start: function() {
                Z.functions.setStates(Z.slideshow, {
                    running: !0,
                    paused: !1
                }), !0 === Z.slideshow.state.pausedByLastCycle && Z.functions.setStates(Z.slideshow, {
                    pausedByLastCycle: !1
                }), Z.gui.navigation.bottom.setStartStop("start"), Z.slideshow.state.pausedByHover || 1 !== Z.transitions._slideTimeline.timeScale() && Z.transitions.layers.timeline.resume(), Z.slideshow.start()
            },
            stop: function() {
                Z.gui.navigation.bottom.setStartStop("stop"), Z.o.pauseLayers && Z.transitions.layers.timeline.pause(), Z.slideshow.stop()
            }
        }, Z.preload = {
            init: function() {
                Z.slider.$hiddenWrapper.find(".ls-slide img").each(function() {
                    var e, t = ee(this),
                        i = t[0],
                        a = {};
                    t.is(".ls-layer, .ls-bg") && (i.getAttribute("width") && (a.width = i.getAttribute("width")), i.getAttribute("height") && (a.height = i.getAttribute("height")), i.sizes && (a.sizes = i.sizes), Z.o.useSrcset && (t.data("srcset") || i.srcset) && (a.srcSet = t.data("srcset") || i.srcset, a.curSrc = i.currentSrc, e = a.srcSet.split(",").map(function(e) {
                        return parseInt(ee.trim(e).split(" ")[1])
                    }), a.maxWidth = Math.max.apply(null, e)), t.removeAttr("width height sizes srcset loading"), ee.isEmptyObject(a) || (t.data(Z.defaults.init.dataKey).attributes = a)), t.data("lazy-src") ? t.data("src", t.data("lazy-src")) : t.attr("data-lazy-src") ? t.data("src", t.attr("data-lazy-src")) : t.attr("data-lazy") ? t.data("src", t.attr("data-lazy")) : t.data("src") ? a.curSrc && t.data("src", a.curSrc) : t.data("src", a.curSrc || i.src), t.attr("src", "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7")
                })
            },
            imagesOfSlide: function(e, t) {
                var i, a, s;
                !0 !== Z.slides[e].wrapped ? (this.slideIndex = e, t ? (this.onCompleteCallback = t, Z.functions.setStates(Z.slider, {
                    preloadingImages: !0
                }), Z.gui.loadingIndicator.show()) : this.onCompleteCallback = !1, Z.slider.canShow && $.css({
                    visibility: "visible"
                }), this.preImages = [], i = this, Z.slider.$hiddenWrapper.find(".ls-slide:eq(" + (i.slideIndex - 1) + ") *").each(function() {
                    a = ee(this), s = this;
                    var e, t = a.data(Z.defaults.init.dataKey);
                    a.is("img") ? (a.data("src") && a.attr("src", a.data("src")), t && t.attributes && t.attributes.srcSet && Z.o.useSrcset && (s.srcset = t.attributes.srcSet), e = s.src, (t = !!(t && t.attributes && t.attributes.curSrc) && t.attributes.curSrc) && e !== t && a.is(".ls-bg") && (e = t, Z.slides[i.slideIndex].data.$background.attr("src", e)), Z.preload.preImages.push([e, a])) : "none" !== a.css("background-image") && -1 !== a.css("background-image").indexOf("url") && Z.preload.preImages.push([a.css("background-image").match(/url\(['"]?(.+?)['"]?\)/)[1], a])
                }), Z.transitions.firstSlide && Z.o.globalBGImage && Z.preload.preImages.push([Z.o.globalBGImage, ee()]), this.thumbnailsAreLoaded || this.thumbnails(), 0 === this.preImages.length ? this.onComplete() : this.start()) : Z.slider.shouldResize && t && (Z.resize.setLayers(Z.layers.get("next, bg")), Z.resize.layers(t))
            },
            thumbnails: function() {
                for (var e = Z.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() {
                Z.debugMode && (Z.debug.add("group", "preload"), Z.debug.add("log", "preload.info", this.slideIndex)), this.preloadedImagesCount = 0;
                for (var e, t = this, i = function() {
                        ++t.preloadedImagesCount == t.preImages.length && (Z.debugMode && Z.debug.groupEnd(), t.onComplete())
                    }, a = function() {
                        Z.debugMode && (e = this.src.substring(this.src.lastIndexOf("/") + 1, this.src.length), Z.debug.add("log", "preload.success", e)), this.originalLayer.data("preloadedWidth", this.width), this.originalLayer.data("preloadedHeight", this.height), i()
                    }, s = function() {
                        Z.debugMode && (e = this.src.substring(this.src.lastIndexOf("/") + 1, this.src.length), Z.debug.add("warn", "preload.fail", e)), i()
                    }, r = 0; r < this.preImages.length; r++) {
                    var o = new Image;
                    o.addEventListener("error", s, !1), o.addEventListener("load", a, !1), o.src = this.preImages[r][0], o.originalLayer = this.preImages[r][1]
                }
            },
            onComplete: function() {
                var s = this;
                this.onCompleteCallback ? (Z.layers.wrap(this.slideIndex), function e() {
                    var t, i, a;
                    0 !== Z.slides[s.slideIndex].$layers.length ? Z.timeouts.waitForWrap = setTimeout(e, 100) : (delete Z.timeouts.waitForWrap, Z.functions.setStates(Z.transitions.layers.parallax, {
                        ready: !0
                    }), ee(".ls-thumbnail-wrapper, .ls-nav-next, .ls-nav-prev, .ls-bottom-nav-wrapper").css({
                        visibility: "visible"
                    }), Z.slides[s.slideIndex].wrapped = !0, t = !(!window._layerSlider.globals.youTubeIsReady && Z.layers.get("next,in,youtube,bgvideo").length), i = !(!window._layerSlider.globals.vimeoIsReady && Z.layers.get("next,in,vimeo,bgvideo").length), a = function() {
                        Z.gui.loadingIndicator.hide(), Z.slider.shouldResize ? (Z.resize.setLayers(Z.layers.get("next, bg")), Z.resize.layers(s.onCompleteCallback)) : s.onCompleteCallback()
                    }, t && i ? a() : Z.intervals.waitForJSApisLoaded = setInterval(function() {
                        (t || window._layerSlider.globals.youTubeIsReady) && (i || window._layerSlider.globals.vimeoIsReady) && (clearInterval(Z.intervals.waitForJSApisLoaded), delete Z.intervals.waitForJSApisLoaded, a())
                    }, 50))
                }()) : Z.layers.wrap(this.slideIndex, !0), Z.functions.setStates(Z.slider, {
                    preloadingImages: !1
                })
            }
        }, Z.resize = {
            setLayers: function(e) {
                this.$responsiveLayers = e.add(Z.layers.get("active")), Z.slides.next.data.$backgroundVideo.length && (this.$responsiveLayers = this.$responsiveLayers.add(Z.slides.next.data.$backgroundVideo))
            },
            all: function() {
                if (!document.body.contains(I)) return !1;
                Z.api.hasEvent("sliderWillResize") && Z.api.triggerEvent("sliderWillResize", Z.api.eventData()), this.slider(), this.navigation(), this.layers(), this.yourLogo(), this.shadow(), this.timers(), Z.transitions.layers.timeline.shouldRestart && Z.o.allowRestartOnResize && (Z.functions.resetSlideTimelines(), Z.transitions.layers.timeline.create(!0)), Z.api.hasEvent("sliderDidResize") && Z.api.triggerEvent("sliderDidResize", Z.api.eventData())
            },
            viewport: function() {
                ee(window).scrollTop(Math.round(Z.slider.offsetTop) - (Z.device.viewportHeight - Z.slider.height) / 2)
            },
            slider: function() {
                if (!document.body.contains(I)) return !1;
                var e, t = Z.slider.$parentWithNumericWidthValue && 0 < Z.slider.$parentWithNumericWidthValue.width() ? Z.slider.$parentWithNumericWidthValue : Z.functions.getSliderClosestParentElementWithNumericValueOfProperty("width"),
                    i = Z.slider.initial,
                    a = Z.slider.$parentWithNumericWidthValuePercent ? t.width() / 100 * Z.slider.$parentWithNumericWidthValuePercent : t.width(),
                    s = i.type,
                    r = 0 !== i.maxWidth ? i.maxWidth : a,
                    o = "auto" === i.marginLeft ? 0 : i.marginLeft,
                    n = "auto" === i.marginRight ? 0 : i.marginRight;
                switch (Z.slider.state.inFullscreen ? $[0].style.maxWidth = "" : 0 !== i.maxWidth && ($[0].style.maxWidth = i.maxWidth + "px"), -1 !== r.indexOf("%") && (r = a / 100 * parseInt(r)), r < (a -= o + n) && 0 <= r && (a = r), Z.o.fitScreenWidth && ("fullwidth" === s || "fullsize" === s && "fitheight" !== Z.o.fullSizeMode && "fitwidth" !== Z.o.fullSizeMode) && (o = t.offset().left, n = parseInt(t.css("padding-left")) || 0, r = parseInt(t.css("border-left-width")) || 0, $[0].style.maxWidth = "none", $[0].style.marginLeft = -(o + n + r) + "px", a = Z.device.viewportWidth || ee(window).width()), a -= i.skinWidth, Z.slider.state.inFullscreen && (a = Z.device.width), s) {
                    case "responsive":
                        e = (Z.slider.state.inFullscreen ? (Z.device.ratio > i.ratio ? this.ratio = Z.device.height / i.height : this.ratio = Z.device.width / i.width, a = Math.round(i.width * this.ratio)) : this.ratio = a / i.width, Math.round(i.height * this.ratio));
                        break;
                    case "fullwidth":
                        e = a < Z.o.responsiveUnder ? (this.ratio = a / Z.o.responsiveUnder, Math.round(i.height * this.ratio)) : Z.slider.state.inFullscreen ? Z.device.ratio > i.layersWidth / i.height ? (this.ratio = Z.device.height / i.height, Z.device.height) : (this.ratio = Z.device.width / i.layersWidth, i.height * this.ratio) : (this.ratio = 1, i.height);
                        break;
                    case "fullsize":
                        switch (Z.o.fullSizeMode.toLowerCase()) {
                            case "normal":
                                e = Z.device.viewportHeight - i.skinHeight;
                                break;
                            case "hero":
                                e = Z.device.viewportHeight - i.skinHeight, Z.slider.state.inFullscreen || (e -= Z.slider.heroTop || Z.slider.offsetTop) <= 0 && (e = Z.device.viewportHeight - i.skinHeight);
                                break;
                            case "fitheight":
                                a = t.width() - i.skinWidth, e = t.height() - i.skinHeight;
                                break;
                            case "fitwidth":
                                a = t.width() - i.skinWidth, e = Z.device.viewportHeight - i.skinHeight
                        }
                        a / e < i.ratio ? this.ratio = a / i.layersWidth : this.ratio = e / i.layersHeight;
                        break;
                    case "fixed":
                    case "fixedsize":
                        this.ratio = 1, a = i.width, e = i.height, Z.o.maxRatio = 1, I.style.maxWidth = "none"
                }
                this.ratio = Z.o.maxRatio && 0 < Z.o.maxRatio && this.ratio > Z.o.maxRatio ? Z.o.maxRatio : this.ratio, I.style.width = a + "px", I.style.height = e + "px", Z.slider.width = a, Z.slider.height = e;
                s = $.offset();
                Z.slider.offsetX = s.left, Z.slider.offsetY = s.top, Z.device.isMobile ? Z.device.viewportWidth < 1025 && 767 < Z.device.viewportWidth ? $.removeClass("ls-device-is-phone").addClass("ls-device-is-tablet") : Z.device.viewportWidth < 768 && $.removeClass("ls-device-is-tablet").addClass("ls-device-is-phone") : $.removeClass("ls-device-is-phone ls-device-is-tablet").addClass("ls-device-is-desktop");
                let l, d;
                Z.o.marginTop && (l = -1 != Z.o.marginTop.indexOf("sh") ? Z.slider.height / 100 * parseInt(Z.o.marginTop) : Z.o.marginTop), Z.o.marginBottom && (d = -1 != Z.o.marginBottom.indexOf("sh") ? Z.slider.height / 100 * parseInt(Z.o.marginBottom) : Z.o.marginBottom), Z.slider.$spacingWrapper.css({
                    marginTop: l,
                    marginBottom: d
                })
            },
            borderRadius: function(e) {
                ee.isNumeric(e) && (e = e.toString());
                let i = Z.o.maxRatio && 0 < Z.o.maxRatio && this.ratio > Z.o.maxRatio ? Z.o.maxRatio : this.ratio,
                    a = "";
                return ee.each(e.split(" "), function(e, t) {
                    -1 == t.indexOf("%") && -1 == t.indexOf("em") ? a += Math.round(parseInt(t) * i) + "px " : a += t + " "
                }), ee.trim(a)
            },
            convertSingleValue: function(e) {
                var t = Z.o.maxRatio && 0 < Z.o.maxRatio && this.ratio > Z.o.maxRatio ? Z.o.maxRatio : this.ratio;
                return -1 == e.indexOf("em") ? Math.round(parseInt(e) * t) + "px " : e
            },
            layers: function(e) {
                if (this.$responsiveLayers) {
                    Z.debugMode && Z.debug.add("group", "resize");
                    for (var t, i = this.$responsiveLayers, a = Z.slider.initial, s = Z.slider.width, r = Z.slider.height, o = s / r, n = [], l = [], d = [], c = [], u = 0, p = 0, h = window.LS_previewZoom || 1, m = 0, f = i.length; m < f; m++) {
                        var g = i[m],
                            y = ee(g),
                            v = y.data(Z.defaults.init.dataKey),
                            b = !!v.is.insideLayerGroup && y.data("$layerGroup"),
                            w = !!v.is.insideLayerGroup && b.data(Z.defaults.init.dataKey),
                            S = v.original,
                            x = this.ratio;
                        v.settings.minresponsiveratio && x < v.settings.minresponsiveratio && (x = v.settings.minresponsiveratio), v.settings.maxresponsiveratio && x > v.settings.maxresponsiveratio && (x = v.settings.maxresponsiveratio), v.settings.calculatedratio = x, t = "responsive" === a.type && -1 !== Z.o.maxRatio ? a.width : a.layersWidth, I = "responsive" === a.type && -1 !== Z.o.maxRatio ? a.height : a.layersHeight, M = t, p = "fullsize" === a.type || "fullwidth" === a.type || "responsive" === a.type ? (u = 0 < t ? (s - t * x) / 2 : 0, 0 < I ? (r - I * x) / 2 : 0) : (u = u < 0 ? 0 : u, p < 0 ? 0 : p);
                        var T = "fixed" == v.settings.position || "fixedx" == v.settings.position,
                            C = "fixed" == v.settings.position || "fixedy" == v.settings.position,
                            k = s,
                            O = r,
                            P = T ? 0 : u,
                            L = C ? 0 : p,
                            I = v.is.insideLayerGroup ? (C = T = !1, L = P = 0, t = k = w.responsive.width, O = w.responsive.height) : (t = M, I),
                            $ = {
                                width: T && 0 !== S.percentWidth ? k / 100 * S.percentWidth : S.width * x,
                                height: C && 0 !== S.percentHeight ? O / 100 * S.percentHeight : S.height * x,
                                paddingLeft: this.convertSingleValue(S.paddingLeft),
                                paddingTop: this.convertSingleValue(S.paddingTop),
                                paddingRight: this.convertSingleValue(S.paddingRight),
                                paddingBottom: this.convertSingleValue(S.paddingBottom),
                                borderLeftWidth: this.convertSingleValue(S.borderLeftWidth),
                                borderTopWidth: this.convertSingleValue(S.borderTopWidth),
                                borderRightWidth: this.convertSingleValue(S.borderRightWidth),
                                borderBottomWidth: this.convertSingleValue(S.borderBottomWidth),
                                borderRadius: this.borderRadius(S.borderRadius)
                            },
                            B = {
                                marginLeft: S.marginLeft * x,
                                marginTop: S.marginTop * x
                            },
                            W = {},
                            M = {
                                borderRadius: $.borderRadius
                            };
                        if ((T || C) && (S.percentHeight || S.percentWidth) && v.is.imageLayer && (S.percentHeight && !S.percentWidth && ($.width = S.width * ($.height / S.height)), S.percentWidth && !S.percentHeight && ($.height = S.height * ($.width / S.width))), ("number" == typeof S.width && S.width < 0 || "auto" == S.width || "" == S.sWidth) && Z.debugMode && Z.debug.add("warn", "resize.width", [m + 1, S.width]), ("number" == typeof S.height && S.height < 0 || "auto" == S.height || "" == S.sHeight) && Z.debugMode && Z.debug.add("warn", "resize.height", [m + 1, S.height]), v.is.textLayer && ($.fontSize = S.fontSize * x, Z.device.isMobile && $.fontSize < v.styleSettings.minmobilefontsize ? $.fontSize = v.styleSettings.minmobilefontsize : $.fontSize < v.styleSettings.minfontsize && ($.fontSize = v.styleSettings.minfontsize), _ = $.fontSize / S.fontSize, $.fontSize += "px", -1 !== S.lineHeight.indexOf("px") && ($.lineHeight = parseFloat(S.lineHeight) * _ + "px"), -1 !== S.letterSpacing.indexOf("px") && ($.letterSpacing = parseFloat(S.letterSpacing) * _ + "px"), -1 !== S.textStrokeWidth.indexOf("px") && ($.textStrokeWidth = parseFloat(S.textStrokeWidth) * _ + "px"), "" == S.sWidth && ($.width = "auto", v.elements.$innerWrapper.addClass("ls-force-width-auto"), "nowrap" !== y.css("white-space") && (v.elements.$_innerWrappers.addClass("ls-force-left-0"), v.elements.$_outerWrappers.addClass("ls-force-full-size"))), "" == S.sHeight && ($.height = "auto", v.elements.$innerWrapper.addClass("ls-force-height-auto")), "" != S.sWidth && "" != S.sHeight || y.css($)), v.is.slideBackground || v.is.backgroundVideo)
                            if (v.is.slideBackground) {
                                var _ = Z.slides[v.is.onSlide].data.backgroundSize;
                                switch ((void 0 !== _ && "inherit" !== _ ? _ : Z.o.slideBGSize).replace("100% 100%", "stretch")) {
                                    case "auto":
                                        break;
                                    case "cover":
                                        S.ratio < o ? ($.width = s, $.height = $.width / S.ratio) : ($.height = r, $.width = $.height * S.ratio);
                                        break;
                                    case "contain":
                                        S.ratio < o ? ($.height = r, $.width = $.height * S.ratio) : ($.width = s, $.height = $.width / S.ratio);
                                        break;
                                    case "stretch":
                                        $.width = s, $.height = r
                                }
                                $.width = Math.round($.width), $.height = Math.round($.height);
                                var z, _ = Z.slides[v.is.onSlide].data.backgroundPosition;
                                switch ((z = (void 0 !== _ ? _ : Z.o.slideBGPosition).split(" "))[0]) {
                                    case "left":
                                        $.x = 0;
                                        break;
                                    case "center":
                                        $.x = (Z.slider.width - $.width) / 2;
                                        break;
                                    case "right":
                                        $.x = Z.slider.width - $.width;
                                        break;
                                    default:
                                        -1 !== z[0].indexOf("%") ? $.x = (Z.slider.width - $.width) / 100 * parseInt(z[0]) : $.x = parseInt(z[0])
                                }
                                if (void 0 !== z[1]) switch (z[1]) {
                                    case "top":
                                        $.y = 0;
                                        break;
                                    case "center":
                                        $.y = (Z.slider.height - $.height) / 2;
                                        break;
                                    case "bottom":
                                        $.y = Z.slider.height - $.height;
                                        break;
                                    default:
                                        -1 !== z[1].indexOf("%") ? $.y = (Z.slider.height - $.height) / 100 * parseInt(z[1]) : $.y = parseInt(z[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 v.is.backgroundVideo && (S.ratio < o ? ($.width = s, $.height = $.width / S.ratio) : ($.height = r, $.width = $.height * S.ratio), $.x = (Z.slider.width - $.width) / 2, $.y = (Z.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 (v.mediaSettings.fullsize) switch (v.mediaSettings.fillmode) {
                                default:
                                    case "cover":
                                    S.ratio < o ? ($.width = s, $.height = $.width / S.ratio) : ($.height = r, $.width = $.height * S.ratio);
                                break;
                                case "contain":
                                        S.ratio > o ? ($.width = s, $.height = $.width / S.ratio) : ($.height = r, $.width = $.height * S.ratio)
                            }
                            v.elements.$_innerWrappers.addClass("ls-force-display-block ls-force-no-transform"), y.addClass("ls-force-no-transform"), v.is.insideLayerGroup && ((w = (b = y.data("$layerGroup")).data(Z.defaults.init.dataKey)).elements.$_innerWrappers.addClass("ls-force-display-block ls-force-no-transform"), b.addClass("ls-force-no-transform")), "auto" == $.width ? $.outerWidth = Math.ceil(y.outerWidth()) : $.outerWidth = $.width + Z.layers.toNum($.paddingLeft, $.fontSize) + Z.layers.toNum($.paddingRight, $.fontSize) + Z.layers.toNum($.borderLeftWidth, $.fontSize) + Z.layers.toNum($.borderRightWidth, $.fontSize), "auto" == $.height ? $.outerHeight = Math.ceil(y.outerHeight()) : $.outerHeight = $.height + Z.layers.toNum($.paddingTop, $.fontSize) + Z.layers.toNum($.paddingBottom, $.fontSize) + Z.layers.toNum($.borderTopWidth, $.fontSize) + Z.layers.toNum($.borderBottomWidth, $.fontSize), v.elements.$_allWrappers.removeClass("ls-force-display-block ls-force-no-transform ls-force-width-auto ls-force-height-auto ls-force-left-0 ls-force-full-size"), y.removeClass("ls-force-no-transform"), v.is.insideLayerGroup && (w.elements.$_allWrappers.removeClass("ls-force-display-block ls-force-no-transform ls-force-width-auto ls-force-height-auto ls-force-left-0 ls-force-full-size"), b.removeClass("ls-force-no-transform")), B.width = W.width = $.outerWidth, B.height = W.height = $.outerHeight, -1 != S.left.indexOf("%") ? "100%" === S.left ? $.left = 0 === P ? k / 100 * parseFloat(S.left) - $.outerWidth : P + t * x / 100 * parseFloat(S.left) - $.outerWidth : "0%" === S.left ? $.left = 0 === P ? 0 : P : $.left = 0 === P ? k / 100 * parseFloat(S.left) - $.outerWidth / 2 : P + t * x / 100 * parseFloat(S.left) - $.outerWidth / 2 : $.left = P + parseFloat(S.left) * x, B.left = $.left, -1 != S.top.indexOf("%") ? "100%" === S.top ? $.top = 0 === L ? O / 100 * parseFloat(S.top) - $.outerHeight : L + I * x / 100 * parseFloat(S.top) - $.outerHeight : "0%" === S.top ? $.top = 0 === L ? 0 : L + 0 : $.top = 0 === L ? O / 100 * parseFloat(S.top) - $.outerHeight / 2 : L + I * x / 100 * parseFloat(S.top) - $.outerHeight / 2 : $.top = L + parseFloat(S.top) * x, B.top = $.top
                        }
                        v.textIn.$nodesForBackgroundClip && v.textIn.$nodesForBackgroundClip.length && (v.elements.$outerStyleWrapper.addClass("ls-force-visibility-hidden ls-force-display-block"), v.elements.$_innerWrappers.addClass("ls-force-no-transform"), L = !1, "auto" === g.style.width && (g.style.width = Math.ceil(v.original.width * (h * x)) + "px", L = !0), v.textIn.$nodesForBackgroundClip.each(function(e, t) {
                            var i = ee(t),
                                a = i.children(".ls-textnode-bgclip-wrap"),
                                t = a.children(".ls-textnode"),
                                i = (i.children(".ls-textnode-dummy"), i.position());
                            a.css({
                                width: Math.ceil(B.width),
                                height: Math.ceil(B.height),
                                transform: "translate(" + -i.left / h + "px," + -i.top / h + "px)"
                            }), t.css({
                                marginLeft: i.left / h,
                                marginTop: i.top / h
                            })
                        }), L = L && !(g.style.width = "auto"), v.elements.$_innerWrappers.removeClass("ls-force-no-transform"), v.elements.$outerStyleWrapper.removeClass("ls-force-visibility-hidden ls-force-display-block")), v.responsive = $, n[m] = $, v.is.slideBackground || v.is.backgroundVideo || (v.settings.wrapperData.responsive = B, l[m] = B, d[m] = W, c[m] = M)
                    }
                    for (var D = 0, A = n.length; D < A; D++) {
                        var F = ee(i[D]),
                            R = F.data(Z.defaults.init.dataKey);
                        F.css(n[D]), R.is.slideBackground || R.is.backgroundVideo ? (R.is.slideBackground || R.is.backgroundVideo) && (R.elements.$bgOuterWrapper.css({
                            width: Z.slider.width,
                            height: Z.slider.height
                        }), R.elements.$outerWrapper.css({
                            width: Z.slider.width,
                            height: Z.slider.height
                        })) : (F.find(".split-item").css(c[D]), this.wrappers(F, R, l[D], d[D]))
                    }
                    void 0 !== e && e(), Z.debugMode && Z.debug.groupEnd("resize")
                }
            },
            wrappers: function(e, t, i, a) {
                i && t.elements.$outerStyleWrapper.css(i), a && t.loop.enabled && t.elements.$loopWrapper.css(a), J.TweenMax.set(t.elements.$wrapper[0], {
                    autoCSS: !1,
                    css: {
                        transformPerspective: t.transformPerspective.layer * Z.resize.ratio
                    }
                }), t.loop.enabled && J.TweenMax.set(t.elements.$loopWrapper[0], {
                    autoCSS: !1,
                    css: {
                        transformPerspective: t.transformPerspective.loop * Z.resize.ratio
                    }
                }), t.hover.enabled && J.TweenMax.set(e[0], {
                    autoCSS: !1,
                    css: {
                        transformPerspective: t.transformPerspective.hover * Z.resize.ratio
                    }
                }), t.textIn.nodes && J.TweenMax.set(t.textIn.nodes, {
                    autoCSS: !1,
                    css: {
                        transformPerspective: t.transformPerspective.text * Z.resize.ratio
                    }
                }), t.textOut.nodes && J.TweenMax.set(t.textOut.nodes, {
                    autoCSS: !1,
                    css: {
                        transformPerspective: t.transformPerspective.text * Z.resize.ratio
                    }
                }), t.parallax.enabled && J.TweenMax.set(t.elements.$parallaxWrapper[0], {
                    autoCSS: !1,
                    css: {
                        transformPerspective: t.transformPerspective.parallax * Z.resize.ratio
                    }
                }), t.scroll.enabled && J.TweenMax.set(t.elements.$scrollTransformWrapper[0], {
                    autoCSS: !1,
                    css: {
                        transformPerspective: t.transformPerspective.scroll * Z.resize.ratio
                    }
                })
            },
            performTransformOperations: function(e, t) {
                var i, a, s, r;
                for (r in t)
                    if ("string" == typeof t[r] && -1 !== t[r].indexOf("="))
                        if (a = (i = t[r].split("="))[0].trim() || !1, s = parseFloat(i[1].trim()) || !1, a && s && ee.isNumeric(s)) switch (a) {
                            case "+":
                                t[r] = e[r] + s;
                                break;
                            case "-":
                                t[r] = e[r] - s;
                                break;
                            case "*":
                                t[r] = e[r] * s;
                                break;
                            case "/":
                                t[r] = e[r] / s
                        } else t[r] = e[r]
            },
            mirrorTransitionProperties: function(o) {
                function n(e) {
                    var t = e;
                    switch (e) {
                        case "left":
                            t = "right";
                            break;
                        case "right":
                            t = "left";
                            break;
                        case "top":
                            t = "bottom";
                            break;
                        case "bottom":
                            t = "top"
                    }
                    return -1 !== e.indexOf("lw") || -1 !== e.indexOf("lh") || -1 !== e.indexOf("sw") || -1 !== e.indexOf("sh") ? t = "-" === e.charAt(0) ? e.substring(1) : "-" + e : -1 !== e.indexOf("%") ? t = -1 * parseFloat(e.split("%")[0]) + "%" : ee.isNumeric(e) && 0 !== e && "0" !== e && (t = -1 * e), t
                }

                function e(e) {
                    var t, i, a, s;
                    for (s in e)
                        if (a = s.toLowerCase(), -1 !== o.mirrorProperties.indexOf(a)) {
                            if ("object" == typeof(t = e[s]))
                                for (var r in i = [], t) i.push(n(t[r]));
                            else i = n(t);
                            e[s] = i
                        }
                }
                e(o.transitionProperties), o.transitionPropertiesShouldBeConverted && e(o.transitionPropertiesShouldBeConverted)
            },
            transformProperties: function(e, t, i, a, s, r) {
                if ("object" == typeof a.x) {
                    for (var o = [], n = 0; n < a.x.length; n++) "string" == typeof a.x[n] ? o[n] = this.getXY(e, t, a.x[n], "Width") : o[n] = a.x[n] * t.settings.calculatedratio;
                    i.cycle.x = o
                } else "string" == typeof a.x ? i.x = this.getXY(e, t, a.x, "Width") : void 0 !== a.x && (i.x = a.x * t.settings.calculatedratio);
                if ("object" == typeof a.y) {
                    for (var l = [], d = 0; d < a.y.length; d++) "string" == typeof a.y[d] ? l[d] = this.getXY(e, t, a.y[d], "Height") : l[d] = a.y[d] * t.settings.calculatedratio;
                    i.cycle.y = l
                } else "string" == typeof a.y ? i.y = this.getXY(e, t, a.y, "Height") : void 0 !== a.y && (i.y = a.y * t.settings.calculatedratio);
                if (s && (i = s), "object" == typeof a.transformOrigin || r) {
                    var c = [];
                    if (r) e.data(Z.defaults.init.dataKey).elements.$outerStyleWrapper.addClass("ls-force-visibility-hidden ls-force-display-block ls-fix-textnodes"), c = Z.functions.convert.nodesTransformOrigin(a.transformOrigin, r, t, e.data(Z.defaults.init.dataKey).elements.$outerStyleWrapper), e.data(Z.defaults.init.dataKey).elements.$outerStyleWrapper.removeClass("ls-force-visibility-hidden ls-force-display-block ls-fix-textnodes");
                    else
                        for (var u = 0; u < a.transformOrigin.length; u++) c[u] = Z.functions.convert.transformOrigin(a.transformOrigin[u], e, t, e.data(Z.defaults.init.dataKey).elements.$outerStyleWrapper);
                    i.cycle.transformOrigin = c
                } else "string" == typeof a.transformOrigin && (i.transformOrigin = Z.functions.convert.transformOrigin(a.transformOrigin, e, t, e.data(Z.defaults.init.dataKey).elements.$outerStyleWrapper))
            },
            styleProperties: function(e, t, i) {
                void 0 !== i.width && (ee.isNumeric(i.width) ? t.width = parseInt(i.width) * e.settings.calculatedratio : "string" == typeof i.width && -1 !== i.width.indexOf("%") && (t.width = Z.slider.width / 100 * parseInt(i.width))), void 0 !== i.height && (ee.isNumeric(i.height) ? t.height = parseInt(i.height) * e.settings.calculatedratio : "string" == typeof i.height && -1 !== i.height.indexOf("%") && (t.height = Z.slider.height / 100 * parseInt(i.height))), i.borderRadius && (t.borderRadius = Z.resize.borderRadius(i.borderRadius))
            },
            clip: function(e, t, i, a) {
                i = ee.trim(i.replace("rect(", "").replace(")", ""));
                for (var s, e = e.data(Z.defaults.init.dataKey).responsive, r = Math.ceil(e.outerWidth), o = Math.ceil(e.outerHeight), n = -1 === i.indexOf(",") ? i.split(" ") : i.split(","), l = "", d = 0; d < n.length; d++)
                    if (-1 !== n[d].indexOf("%")) switch (d) {
                        case 0:
                            l += parseInt(o / 100 * parseInt(n[d]) * 100) / 100 + "px ";
                            break;
                        case 1:
                            l += a ? parseInt(100 * (r - r / 100 * parseInt(n[d]))) / 100 + "px " : parseInt(r / 100 * parseInt(n[d]) * 100) / 100 + "px ";
                            break;
                        case 2:
                            l += a ? parseInt(100 * (o - o / 100 * parseInt(n[d]))) / 100 + "px " : parseInt(o / 100 * parseInt(n[d]) * 100) / 100 + "px ";
                            break;
                        case 3:
                            l += parseInt(r / 100 * parseInt(n[d]) * 100) / 100 + "px"
                    } else switch (s = parseInt(n[d]) * t.settings.calculatedratio, d) {
                        case 0:
                            l += s + "px ";
                            break;
                        case 1:
                            l += a ? r - s + "px " : s + "px ";
                            break;
                        case 2:
                            l += a ? o - s + "px " : s + "px ";
                            break;
                        case 3:
                            l += s + "px"
                    }
                    return "rect(" + l + ")"
            },
            getXY: function(e, t, i, a) {
                var s = 0,
                    r = t.original,
                    o = t.responsive,
                    n = t.settings.wrapperData.responsive;
                if (r && o && n) switch (i) {
                    case "left":
                        s = -1 == r.left.indexOf("%") || "100%" === r.left ? -o.left - o.outerWidth - n.marginLeft : -parseInt(r.left) / 100 * Z.slider.width - o.outerWidth / 2 - n.marginLeft;
                        break;
                    case "right":
                        s = -1 == r.left.indexOf("%") || "100%" === r.left ? Z.slider.width - o.left - n.marginLeft : (1 - parseInt(r.left) / 100) * Z.slider.width + o.outerWidth / 2 - n.marginLeft;
                        break;
                    case "top":
                        s = -1 == r.top.indexOf("%") || "100%" === r.top ? -o.top - o.outerHeight - n.marginTop : -parseInt(r.top) / 100 * Z.slider.height - o.outerHeight / 2 - n.marginTop;
                        break;
                    case "bottom":
                        s = -1 == r.top.indexOf("%") || "100%" === r.top ? Z.slider.height - o.top - n.marginTop : (1 - parseInt(r.top) / 100) * Z.slider.height + o.outerHeight / 2 - n.marginTop;
                        break;
                    case "width":
                        s = o.outerWidth;
                        break;
                    case "-width":
                        s = -o.outerWidth;
                        break;
                    case "height":
                        s = o.outerHeight;
                        break;
                    case "-height":
                        s = -o.outerHeight;
                        break;
                    default:
                        s = -1 !== i.indexOf("%") ? o["outer" + a] / 100 * parseInt(i) : -1 !== i.indexOf("sw") ? parseInt(i.split("sw")[0]) / 100 * Z.slider.width : -1 !== i.indexOf("sh") ? parseInt(i.split("sh")[0]) / 100 * Z.slider.height : -1 !== i.indexOf("lw") ? o.outerWidth / 100 * parseInt(i.split("lw")[0]) : -1 !== i.indexOf("lh") ? o.outerHeight / 100 * parseInt(i.split("lh")[0]) : parseInt(i) * t.settings.calculatedratio
                }
                return s
            },
            navigation: function() {
                "always" == Z.o.thumbnailNavigation && Z.gui.navigation.bottom.thumbnails.resize()
            },
            shadow: function() {
                Z.gui.shadow.show && Z.gui.shadow.show(), Z.gui.shadow.$element && Z.gui.shadow.resize()
            },
            yourLogo: function() {
                Z.yourLogo.$element && Z.yourLogo.resize()
            },
            timers: function() {
                if (0 < Z.gui.timers.slidebar.$containerElement.length)
                    for (var e = 0, t = Z.gui.timers.slidebar.$containerElement.length; e < t; e++) Z.gui.timers.slidebar.containerElementWidth[e] = Z.gui.timers.slidebar.$containerElement[e].width(), Z.gui.timers.slidebar.elementWidth[e] = Z.gui.timers.slidebar.$element[e].width()
            }
        }, Z.transitions = {
            firstSlide: !0,
            timelines: {
                all: ["_slideTimeline", "_slideTimelineAlternate", "_forceLayersOut", "_forceLayersOutMirror", "_forceLayersOutPrevious", "_forceLayersOutMirrorPrevious", "_forceLayersOutMirrorPrevious"],
                slide: ["_slideTransition"],
                layers: ["_slideTimeline", "_slideTimelineAlternate"],
                allforce: ["_forceLayersOut", "_forceLayersOutMirror", "_forceLayersOutPrevious", "_forceLayersOutMirrorPrevious"],
                prevforce: ["_forceLayersOutPrevious", "_forceLayersOutMirrorPrevious"],
                currentforce: ["_forceLayersOut", "_forceLayersOutMirror"],
                mirrorforce: ["_forceLayersOutMirror", "_forceLayersOutMirrorPrevious"],
                set: function(e, t) {
                    for (var i in this[e]) Z.transitions[this[e][i]] && t(Z.transitions[this[e][i]], this[e][i])
                }
            },
            start: function() {
                return !!document.body.contains(I) && (Z.slider.isPopup && Z.slider.state.popupIsWaitingForDelay ? !(Z.slider.state.waitingForPopupTimer = !0) : (Z.device.scroll.directionAtSlideTransitionStart = Z.device.scroll.direction, "always" == Z.o.thumbnailNavigation && (Z.gui.navigation.bottom.thumbnails.change(), "ontouchstart" in window || Z.gui.navigation.bottom.thumbnails.scroll()), this.layers.out.forced(), void this.slide.init()))
            },
            slide: {
                $wrapper: ee(),
                init: function() {
                    var e, t, i;
                    Z.functions.setStates(Z.slider, {
                        animatingSlides: !0
                    }), Z.transitions.layers.parallax.reset(), Z.slider.$layersWrapper.children('.ls-parallax[data-ls-parallax="active"]').each(function() {
                        ee(this).find(".ls-layer").data(Z.defaults.init.dataKey).settings.slideOut === Z.slides.current.index && ee(this).attr("data-ls-parallax", "disbaled")
                    }), Z.transitions.curSlide = Z.slides.current, Z.transitions.nextSlide = Z.slides.next, Z.transitions._slideTransition = new J.TimelineMax({
                        paused: !0,
                        onComplete: function() {
                            Z.transitions.slide.onComplete()
                        }
                    }), Z.transitions.firstSlide ? (void 0 !== Z.transitions.nextSlide.data.$background && (e = (i = Z.transitions.nextSlide.data.$background.data(Z.defaults.init.dataKey)).kenBurns.zoom ? i.kenBurns.from.scale : 1, t = i.kenBurns.zoom ? i.kenBurns.from.rotation : 0, i = Z.transitions.nextSlide.filter.from || "none", Z.transitions._slideTransition.set(Z.transitions.nextSlide.data.$background[0], {
                        "-webkit-filter": i,
                        filter: i
                    }, 0), Z.transitions._slideTransition.fromTo(Z.transitions.nextSlide.data.$background.closest(".ls-bg-wrap")[0], Z.o.sliderFadeInDuration, {
                        autoCSS: !1,
                        css: {
                            scale: e,
                            rotation: t,
                            opacity: 0,
                            display: "block"
                        }
                    }, {
                        autoCSS: !1,
                        css: {
                            opacity: 1
                        }
                    }, 0)), this.start(!0)) : "undefined" == typeof layerSliderTransitions && "undefined" == typeof layerSliderCustomTransitions ? (this.start(!0), Z.debugMode && Z.debug.add("warn", "slideTransition.noSlideTransition", Z.transitions.nextSlide.index)) : void 0 === Z.transitions.curSlide.data.$background && void 0 === Z.transitions.nextSlide.data.$background && "transparent" == Z.transitions.curSlide.data.backgroundColor && "transparent" == Z.transitions.nextSlide.data.backgroundColor ? this.start(!0) : ("x" === Z.o.clipSlideTransition ? Z.device.$overflowWrapper.addClass("ls-overflowx-hidden") : "y" === Z.o.clipSlideTransition ? Z.device.$overflowWrapper.addClass("ls-overflowy-hidden") : !0 === Z.o.clipSlideTransition && Z.device.$overflowWrapper.addClass("ls-overflow-hidden"), void 0 !== Z.transitions.curSlide.data.$background && (e = Z.transitions.curSlide.data.$background.closest(".ls-bg-wrap")[0]._gsTransform, (t = Z.transitions.curSlide.data.$background.data(Z.defaults.init.dataKey)).responsive.filter = Z.transitions.curSlide.data.$background[0].style.filter, t.responsive.kbRotation = void 0 !== e ? " rotate(" + e.rotation + "deg)" : " rotate(0deg)", t.responsive.kbScale = void 0 !== e ? " scale(" + e.scaleX + ")" : " scale(1)"), Z.transitions.slide.$wrapper = ee("<div>").addClass("ls-slide-transition-wrapper").css({
                        width: Z.slider.width,
                        height: Z.slider.height
                    }), this.select.slideTransitionType())
                },
                select: {
                    slideTransitionType: function() {
                        Z.transitions.slide.normal.select.transitionType()
                    }
                },
                start: function(e) {
                    var t, i = !(!Z.slides.current.index || !Z.slides.current.data.$backgroundVideo.length),
                        a = !(!Z.slides.next.index || !Z.slides.next.data.$backgroundVideo.length);
                    !Z.slideshow.firstStart && Z.api.hasEvent("slideChangeDidStart") && Z.api.triggerEvent("slideChangeDidStart", Z.api.eventData()), e || (void 0 !== Z.transitions.nextSlide.data.transitionDuration ? s = Z.transitions.nextSlide.data.transitionDuration : void 0 !== Z.o.slideTransitionDuration && ee.isNumeric(Z.o.slideTransitionDuration) && -1 < Z.o.slideTransitionDuration && (s = Z.o.slideTransitionDuration / 1e3), ee.isNumeric(s) && (0 === s && (s += 1e-5), Z.transitions._slideTransition.duration(s)), Z.debugMode && Z.debug.options.transitionDuration && Z.transitions._slideTransition.duration(Z.debug.options.transitionDuration), .25 < Z.transitions.layers.timeline.timeScaleModifier && (r = (r = Z.transitions._slideTransition.duration() / (.75 + Z.transitions.layers.timeline.timeScaleModifier)) < .5 ? .5 : r, Z.transitions._slideTransition.duration(r)));
                    var e = Z.transitions._slideTransition.duration() / Z.transitions._slideTransition.timeScale(),
                        s = e,
                        r = Z.transitions.nextSlide.data.timeShift || (void 0 !== Z.o.slideTimeShift && ee.isNumeric(Z.o.slideTimeShift) && Z.o.slideTimeShift < 0 ? Z.o.slideTimeShift / 1e3 : 0);
                    0 < r ? r = 0 : Math.abs(r) > e && (r = -e), Z.transitions.nextSlide.data.calculatedTimeShift = r, r = Z.transitions.firstSlide ? Z.o.sliderFadeInDuration + .01 : (s + r) * Z.transitions._slideTransition.timeScale(), (i || a) && Z.transitions.media.changeBackgroundVideo(Z.transitions.firstSlide, i && a), Z.transitions._slideTransition.call(function() {
                        !Z.slideshow.firstStart && Z.api.hasEvent("slideChangeWillComplete") && Z.api.triggerEvent("slideChangeWillComplete", Z.api.eventData()), Z.slideshow.should.change || Z.transitions.layers.timeline.prepare(), Z.media.functions.stop(!0), Z.slides.set.slideIndexes(), Z.o.hashChange && (document.location.hash = Z.slides[Z.slides.current.index].data.deeplink || "_no-deeplink-found_"), Z.slideshow.start(), !Z.transitions.firstSlide && Z.slides.prev.index && Z.slides.prev.data.$backgroundVideo.length && !Z.slides.prev.data.$backgroundVideo.data(Z.defaults.init.dataKey).mediaProperties.willBePaused && (Z.slides.prev.data.$backgroundVideo.trigger("stopBackgroundVideo"), Z.slides.prev.data.$backgroundVideo.data(Z.defaults.init.dataKey).elements.$bgWrapper.css({
                            display: "none"
                        })), Z.slideshow.should.change || Z.slides.next.data.$backgroundVideo.length && Z.slides.next.data.$backgroundVideo.data(Z.defaults.init.dataKey).mediaProperties && !Z.slides.next.data.$backgroundVideo.data(Z.defaults.init.dataKey).mediaProperties.isPreloaded && (Z.slides.next.data.$backgroundVideo.trigger("preloadBackgroundVideo"), Z.slides.next.data.$backgroundVideo.data(Z.defaults.init.dataKey).mediaProperties.isPreloaded = !0), Z.transitions.firstSlide = !1
                    }, [], this, r), Z.transitions._slideTransition.play(), Z.slideshow.forceFastChange && Z.transitions._slideTransition.progress(1), void 0 !== Z.transitions.curSlide.data && void 0 !== Z.transitions.curSlide.data.$background && (t = Z.transitions.curSlide.data.$background.data(Z.defaults.init.dataKey), Z.timeouts.applyBG = setTimeout(function() {
                        delete Z.timeouts.applyBG, Z.transitions.curSlide.data.$background.closest(".ls-bg-wrap").hide(), t.kenBurns.zoom && J.TweenMax.set(Z.transitions.curSlide.data.$background[0], {
                            autoCSS: !1,
                            css: t.kenBurns.from
                        })
                    }, 5))
                },
                onComplete: function() {
                    var e;
                    void 0 !== Z.transitions.nextSlide.data.$background && Z.transitions.nextSlide.data.$background.closest(".ls-bg-wrap").show(), "transparent" !== Z.transitions.nextSlide.data.backgroundColor ? Z.slider.$slideBGColorWrapper.css("background-color", Z.transitions.nextSlide.data.backgroundColor) : Z.slider.$slideBGColorWrapper.css("background-color", "transparent"), Z.o.leaveOverflow || Z.device.$overflowWrapper.removeClass("ls-overflowx-hidden ls-overflowy-hidden ls-overflow-hidden"), this.$wrapper && (this.$wrapper.html("").remove(), this.$wrapper = !1), Z.gui.navigation.bottom.bullets.set.active(), 0 < Z.o.cycles && (Z.slideshow.hasOwnProperty("cycleSlideIndex") ? Z.slideshow.cycles.check(Z.transitions.nextSlide.index) && (Z.navigation.stop(), Z.functions.setStates(Z.slideshow, {
                        pausedByLastCycle: !0
                    }), Z.o.forceCycles && (Z.slideshow.curCycle = 1)) : Z.slideshow.cycles.set()), Z.functions.setStates(Z.slider, {
                        animatingSlides: !1,
                        changingSlides: !1
                    }), !Z.slideshow.firstStart && Z.api.hasEvent("slideChangeDidComplete") && Z.api.triggerEvent("slideChangeDidComplete", Z.api.eventData()), Z.slideshow.firstStart = !1, Z.slideshow.forceFastChange = !1, Z.slideshow.forceFastChangeCallback && (Z.slideshow.forceFastChangeCallback(), Z.slideshow.forceFastChangeCallback = !1), Z.slideshow.should.change && (Z.navigation.forceDirection ? (void 0 !== Z.transitions.curSlide.data && void 0 !== Z.transitions.curSlide.data.$background && (e = Z.transitions.curSlide.data.$background.data(Z.defaults.init.dataKey), Z.transitions.curSlide.data.$background.closest(".ls-bg-wrap").hide(), e.kenBurns.zoom && J.TweenMax.set(Z.transitions.curSlide.data.$background[0], {
                        autoCSS: !1,
                        css: e.kenBurns.from
                    })), Z.slideshow.changeTo(Z.slideshow.get.slideInSequence(Z.navigation.forceDirection), !0)) : Z.slideshow.forceSlideChangeTo ? Z.slideshow.changeTo(Z.slideshow.forceSlideChangeTo) : Z.preload.imagesOfSlide(Z.slides.next.index))
                },
                normal: {
                    select: {
                        transitionType: function() {
                            var e, t, i;
                            Z.o.slideTransition ? Z.transitions.slide.normal.setTransition(Z.o.slideTransition.type, Z.o.slideTransition.obj) : (i = !!Z.transitions.nextSlide.data.transition2d && Z.transitions.nextSlide.data.transition2d.toString().split(","), Z.device.touchPrev && Z.o.slideOnSwipe ? (Z.device.touchPrev = !1, this.transition("2d", "1")) : Z.device.touchNext && Z.o.slideOnSwipe ? (Z.device.touchNext = !1, this.transition("2d", "1")) : Z.slides.next.data.$background || i && (!i || -1 != i.indexOf("1") || -1 != i.indexOf("2") || -1 != i.indexOf("3") || -1 != i.indexOf("4")) ? Z.browser.supports3D() && (Z.transitions.nextSlide.data.transition3d || Z.transitions.nextSlide.data.customtransition3d) ? Z.transitions.nextSlide.data.transition3d && Z.transitions.nextSlide.data.customtransition3d ? (e = Math.floor(2 * Math.random()), t = [
                                ["3d", Z.transitions.nextSlide.data.transition3d],
                                ["custom3d", Z.transitions.nextSlide.data.customtransition3d]
                            ], this.transition(t[e][0], t[e][1])) : Z.transitions.nextSlide.data.transition3d ? this.transition("3d", Z.transitions.nextSlide.data.transition3d) : this.transition("custom3d", Z.transitions.nextSlide.data.customtransition3d) : Z.transitions.nextSlide.data.transition2d && Z.transitions.nextSlide.data.customtransition2d ? (e = Math.floor(2 * Math.random()), t = [
                                ["2d", Z.transitions.nextSlide.data.transition2d],
                                ["custom2d", Z.transitions.nextSlide.data.customtransition2d]
                            ], this.transition(t[e][0], t[e][1])) : Z.transitions.nextSlide.data.transition2d ? this.transition("2d", Z.transitions.nextSlide.data.transition2d) : Z.transitions.nextSlide.data.customtransition2d ? this.transition("custom2d", Z.transitions.nextSlide.data.customtransition2d) : this.transition("2d", "1") : this.transition("2d", "5"))
                        },
                        transition: function(e, t) {
                            Z.debugMode && Z.debug.add("group", "slideTransition.info"), t += "";
                            var i, a, s = -1 == e.indexOf("custom") ? Z.t : Z.ct,
                                r = "3d"; - 1 != e.indexOf("2d") && (r = "2d"), a = -1 != t.indexOf("last") ? s["t" + r].length - 1 : -1 != t.indexOf("all") ? Math.floor(Math.random() * Z.functions.countProp(s["t" + r])) : (t = (i = t.split(",")).length, parseInt(i[Math.floor(Math.random() * t)]) - 1), void 0 === s["t" + r][a] && (Z.debugMode && Z.debug.add("warn", "slideTransition.customTransition", [r.toUpperCase() + (-1 === e.indexOf("custom") ? "" : " (CUSTOM)"), a + 1]), s = Z.t, e = r = "2d", a = 0), Z.debugMode && Z.debug.add("log", "slideTransition.info", [r.toUpperCase() + (-1 === e.indexOf("custom") ? "" : " (CUSTOM)"), a + 1, s["t" + r][a].name]), Z.transitions.slide.normal.setTransition(r, s["t" + r][a])
                        }
                    },
                    setTransition: function(e, t) {
                        var i, a, s, r, o = ee.extend(!0, {
                                cols: 1,
                                rows: 1
                            }, t),
                            n = typeof o.cols,
                            l = typeof o.rows,
                            d = [],
                            c = Z.navigation.direction,
                            u = 0,
                            p = 0,
                            h = !!Z.transitions.curSlide.data.$background && Z.functions.getURL(Z.transitions.curSlide.data.$background),
                            m = !!Z.transitions.nextSlide.data.$background && Z.functions.getURL(Z.transitions.nextSlide.data.$background),
                            f = Z.o.playByScroll && "up" === Z.device.scroll.direction ? "to" : "from";
                        switch (n) {
                            case "number":
                                n = o.cols;
                                break;
                            case "string":
                                n = Math.floor(Math.random() * (parseInt(o.cols.split(",")[1]) - parseInt(o.cols.split(",")[0]) + 1)) + parseInt(o.cols.split(",")[0]);
                                break;
                            default:
                                n = Math.floor(Math.random() * (o.cols[1] - o.cols[0] + 1)) + o.cols[0]
                        }
                        switch (l) {
                            case "number":
                                l = o.rows;
                                break;
                            case "string":
                                l = Math.floor(Math.random() * (parseInt(o.rows.split(",")[1]) - parseInt(o.rows.split(",")[0]) + 1)) + parseInt(o.rows.split(",")[0]);
                                break;
                            default:
                                l = Math.floor(Math.random() * (o.rows[1] - o.rows[0] + 1)) + o.rows[0]
                        }
                        Z.device.isMobile && Z.o.optimizeForMobile ? (15 <= n ? n = 7 : 5 <= n ? n = 4 : 4 <= n ? n = 3 : 2 < n && (n = 2), 15 <= l ? l = 7 : 5 <= l ? l = 4 : 4 <= l ? l = 3 : 2 < l && (l = 2), 2 < l && 2 < n && (l = 2, 4 < n && (n = 4))) : (n = 35 < n ? 35 : n, l = 35 < l ? 35 : l), Z.debugMode && !Z.o.slideTransition && (Z.debug.add("log", "slideTransition.properties", [
                            [n, l], n * l
                        ]), Z.debug.groupEnd()), i = Math.floor(Z.slider.width / n), a = Math.floor(Z.slider.height / l), s = Z.slider.width - i * n, r = Z.slider.height - a * l, "prev" == c && (t = {
                            random: "random",
                            forward: "reverse",
                            reverse: "forward",
                            center: "center",
                            edge: "edge",
                            mirror: "mirror",
                            "col-forward": "col-reverse",
                            "col-reverse": "col-forward"
                        }, "2d" === e && o.transition && "scale" === o.transition.type && (t.forward = "forward", t.reverse = "reverse"), o.tile && o.tile.sequence && (o.tile.sequence = t[o.tile.sequence]), ee.each(["animation", "before", "after"], function(e, t) {
                            o[t] && o[t].transition && ((t = o[t].transition).rotateX && 44 < Math.abs(t.rotateX) && (t.rotateX *= -1), t.rotateY && 44 < Math.abs(t.rotateY) && (t.rotateY *= -1), t.rotate && (t.rotate *= -1))
                        }));
                        for (var g, y, v = 0; v < n * l; v++) d.push(v);
                        switch (o.tile.sequence) {
                            case "reverse":
                                d.reverse();
                                break;
                            case "col-forward":
                                d = Z.functions.sortArray(l, n, "forward");
                                break;
                            case "col-reverse":
                                d = Z.functions.sortArray(l, n, "reverse");
                                break;
                            case "random":
                                d = Z.functions.shuffleArray(d);
                                break;
                            case "center":
                                d = Z.functions.sortArray(l, n, "center");
                                break;
                            case "edge":
                            case "mirror":
                                d = Z.functions.sortArray(l, n, "edge")
                        }("transparent" === Z.transitions.nextSlide.data.backgroundColor || "3d" == e || void 0 !== Z.transitions.curSlide.data.$background && void 0 !== Z.transitions.nextSlide.data.$background) && Z.slider.$slideBGColorWrapper.css("background-color", "transparent"), "2d" == e && (g = -1 != o.name.toLowerCase().indexOf("carousel"), y = -1 != o.name.toLowerCase().indexOf("crossfad"), this.$curTiles = ee("<div>").addClass("ls-curtiles").appendTo(Z.transitions.slide.$wrapper), this.$nextTiles = ee("<div>").addClass("ls-nexttiles").appendTo(Z.transitions.slide.$wrapper));
                        for (var b = 0; b < n * l; b++) {
                            var w, S = (b + 1) % n == 0 ? s : 0,
                                x = (l - 1) * n - 1 < b ? r : 0,
                                T = ee("<div>").addClass("ls-slide-transition-tile").css({
                                    width: i + S,
                                    height: a + x
                                }).data("style", {
                                    width: i + S,
                                    height: a + x
                                }).appendTo(Z.transitions.slide.$wrapper),
                                u = (d[b], b % n == 0 ? u + 1 : u),
                                p = b % n == 0 ? 1 : p + 1;
                            if ("3d" == e) {
                                T.addClass("ls-3d-container");
                                var C, k, O = i + S,
                                    P = a + x,
                                    L = new J.TimelineMax,
                                    I = Math.abs(Math.abs(p - n / 2 - .5) - n / 2 - .5) * Math.abs(Math.abs(u - l / 2 - .5) - l / 2 - .5);
                                T.css({
                                    zIndex: I
                                }), C = O / 2, k = P / 2, x = (I = "horizontal" == o.animation.direction ? 90 < Math.abs(o.animation.transition.rotateY) && "large" != o.tile.depth ? Math.floor(O / 7) + S : O : 90 < Math.abs(o.animation.transition.rotateX) && "large" != o.tile.depth ? Math.floor(P / 7) + x : P) / 2, this.createCuboids("ls-3d-box", T, 0, 0, 0, 0, -x, 0, 0, C + "px " + k + "px 0px"), this.createCuboids("ls-3d-front", T.find(".ls-3d-box"), O, P, 0, 0, x, 0, 0), "vertical" == o.animation.direction && 90 < Math.abs(o.animation.transition.rotateX) ? this.createCuboids("ls-3d-back", T.find(".ls-3d-box"), O, P, 0, 0, -x, 180, 0) : this.createCuboids("ls-3d-back", T.find(".ls-3d-box"), O, P, 0, 0, -x, 0, 180), this.createCuboids("ls-3d-left", T.find(".ls-3d-box"), I, P, -x, 0, 0, 0, -90), this.createCuboids("ls-3d-right", T.find(".ls-3d-box"), I, P, O - x, 0, 0, 0, 90), this.createCuboids("ls-3d-top", T.find(".ls-3d-box"), O, I, 0, -x, 0, 90, 0), this.createCuboids("ls-3d-bottom", T.find(".ls-3d-box"), O, I, 0, P - x, 0, -90, 0), O = T.find(".ls-3d-front"), I = "horizontal" == o.animation.direction ? 90 < Math.abs(o.animation.transition.rotateY) ? T.find(".ls-3d-back") : 0 < o.animation.transition.rotateY ? T.find(".ls-3d-left") : T.find(".ls-3d-right") : 90 < Math.abs(o.animation.transition.rotateX) ? T.find(".ls-3d-back") : 0 < o.animation.transition.rotateX ? T.find(".ls-3d-bottom") : T.find(".ls-3d-top"), P = d[b] * o.tile.delay, x = Z.transitions.slide.$wrapper.find(".ls-3d-container:eq( " + b + " ) .ls-3d-box"), o.before && o.before.transition ? (o.before.transition.delay = o.before.transition.delay ? (o.before.transition.delay + P) / 1e3 : P / 1e3, L.to(x[0], o.before.duration / 1e3, Z.functions.convert.transition(o.before.transition, o.before.easing))) : o.animation.transition.delay = o.animation.transition.delay ? (o.animation.transition.delay + P) / 1e3 : P / 1e3, L.to(x[0], o.animation.duration / 1e3, Z.functions.convert.transition(o.animation.transition, o.animation.easing)), o.after && (o.after.transition || (o.after.transition = {}), L.to(x[0], o.after.duration / 1e3, Z.functions.convert.transition(o.after.transition, o.after.easing, "after"))), Z.transitions._slideTransition.add(L, 0)
                            } else {
                                var $, B, W, M, _, z = "auto",
                                    D = "auto",
                                    A = "auto",
                                    F = "auto",
                                    R = 1,
                                    E = 1,
                                    N = null,
                                    V = null,
                                    H = null,
                                    X = null,
                                    Y = "50% 50%",
                                    K = "50% 50%",
                                    U = 0,
                                    j = 100,
                                    q = {},
                                    G = o.transition.intensity || 2,
                                    Q = "random" == o.transition.direction ? (W = "scale" == o.transition.type ? ["top", "bottom", "middle", "right", "left", "center"] : ["top", "bottom", "right", "left"])[Math.floor(Math.random() * W.length)] : o.transition.direction;
                                switch (-1 != o.name.toLowerCase().indexOf("mirror") && b % 2 == 0 && (c = "prev" == c ? "next" : "prev"), "prev" == c && (Q = {
                                    top: "bottom",
                                    bottom: "top",
                                    middle: "middle",
                                    left: "right",
                                    right: "left",
                                    center: "center",
                                    topleft: "bottomright",
                                    topright: "bottomleft",
                                    bottomleft: "topright",
                                    bottomright: "topleft"
                                }[Q]), Q) {
                                    case "top":
                                        z = A = -T.data("style").height, D = F = 0;
                                        break;
                                    case "bottom":
                                        z = A = T.data("style").height, D = F = 0;
                                        break;
                                    case "left":
                                        z = A = 0, D = F = -T.data("style").width;
                                        break;
                                    case "right":
                                        z = A = 0, D = F = T.data("style").width;
                                        break;
                                    case "topleft":
                                        z = T.data("style").height, A = 0, D = T.data("style").width, F = 0;
                                        break;
                                    case "topright":
                                        z = T.data("style").height, A = 0, D = -T.data("style").width, F = 0;
                                        break;
                                    case "bottomleft":
                                        z = -T.data("style").height, A = 0, D = T.data("style").width, F = 0;
                                        break;
                                    case "bottomright":
                                        z = -T.data("style").height, A = 0, D = -T.data("style").width, F = 0
                                }
                                switch (this.scale2D = o.transition.scale || 1, 1 == g && 1 != this.scale2D && (z /= 2, A /= 2, D /= 2, F /= 2), (o.transition.rotate || o.transition.rotateX || o.transition.rotateY || 1 != this.scale2D) && "slide" != o.transition.type ? T.css({
                                    overflow: "visible"
                                }) : T.css({
                                    overflow: "hidden"
                                }), 1 == g ? this.$curTiles.css({
                                    overflow: "visible"
                                }) : this.$curTiles.css({
                                    overflow: "hidden"
                                }), !0 === y || "slide" == o.transition.type || "scale" == o.transition.type || !0 === g ? (M = T.appendTo(this.$curTiles), $ = T.clone().appendTo(this.$nextTiles), O = ee("<div>").addClass("ls-curtile").appendTo(M)) : $ = T.appendTo(this.$nextTiles), I = ee("<div>").addClass("ls-nexttile").appendTo($), B = d[b] * o.tile.delay / 1e3, L = o.transition.rotate || 0, W = o.transition.rotateX || 0, M = o.transition.rotateY || 0, "prev" == c && (L = -L, W = -W, M = -M), o.transition.type) {
                                    case "fade":
                                        R = z = A = D = F = 0, E = 1;
                                        break;
                                    case "mixed":
                                        R = 0, (E = 1) == this.scale2D && (A = F = 0);
                                        break;
                                    case "scale":
                                        switch (R = z = A = D = F = 0, V = N = E = 1, Q) {
                                            case "left":
                                            case "right":
                                                N = 1 + d[b] / (50 / G);
                                                break;
                                            case "top":
                                            case "bottom":
                                                V = 1 + d[b] / (50 / G);
                                                break;
                                            case "center":
                                                N = 1 + d[b] / (50 / G);
                                                break;
                                            case "middle":
                                                V = 1 + d[b] / (50 / G)
                                        }
                                        switch ("mirror" === o.tile.sequence && n * l / 2 < b && (U = 100, j = 0), Q) {
                                            case "left":
                                                Y = U + "% 50%", K = j + "% 0";
                                                break;
                                            case "right":
                                                Y = j + "% 50%", K = U + "% 50%";
                                                break;
                                            case "center":
                                            case "middle":
                                                X = H = 1;
                                                break;
                                            case "top":
                                                Y = "50% " + U + "%", K = "50% " + j + "%";
                                                break;
                                            case "bottom":
                                                Y = "50% " + j + "%", K = "50% " + U + "%"
                                        }
                                }
                                Z.transitions._slideTransition.fromTo(I[0], o.transition.duration / 1e3, {
                                    immediateRender: !1,
                                    autoCSS: !1,
                                    css: {
                                        x: -D,
                                        y: -z,
                                        display: "block",
                                        opacity: R,
                                        rotation: L,
                                        rotationX: W,
                                        rotationY: M,
                                        scaleX: N || this.scale2D,
                                        scaleY: V || this.scale2D,
                                        transformOrigin: Y
                                    }
                                }, {
                                    autoCSS: !1,
                                    css: {
                                        x: 0,
                                        y: 0,
                                        opacity: E,
                                        rotation: 0,
                                        rotationX: 0,
                                        rotationY: 0,
                                        scaleX: 1,
                                        scaleY: 1
                                    },
                                    ease: Z.functions.convert.easing(o.transition.easing)
                                }, B), 1 == y && (void 0 === Z.transitions.nextSlide.data.$background || void 0 !== Z.transitions.nextSlide.data.$background && (-1 != Z.transitions.nextSlide.data.$background.attr("src").toLowerCase().indexOf("png") || Z.transitions.nextSlide.data.$background.width() < Z.slider.width || Z.transitions.nextSlide.data.$background.height() < Z.slider.height)) && (q.opacity = 0), "slide" != o.transition.type && 1 != g || -1 != o.name.toLowerCase().indexOf("mirror") ? "scale" == o.transition.type && (q.scaleX = H || N, q.scaleY = X || V, q.transformOrigin = K) : (_ = 0 !== L ? -L : 0, q.x = F, q.y = A, q.rotation = _, q.scale = this.scale2D, q.opacity = R), void 0 !== O && Z.transitions._slideTransition.to(O[0], o.transition.duration / 1e3, {
                                    autoCSS: !1,
                                    css: q,
                                    ease: Z.functions.convert.easing(o.transition.easing)
                                }, B)
                            }
                            _ = b % n * i, q = Math.floor(b / n) * a, void 0 !== Z.transitions.curSlide.data.$background && (w = Z.transitions.curSlide.data.$background.data(Z.defaults.init.dataKey), "3d" === e || "2d" === e && (!0 === y || "slide" === o.transition.type || "scale" === o.transition.type || !0 === g) ? O.append(ee('<div style="position: absolute;">').css({
                                width: Z.slider.width,
                                height: Z.slider.height,
                                left: -_,
                                top: -q,
                                transform: w.responsive.kbRotation + w.responsive.kbScale
                            }).append(ee("<img>").attr("src", h).css({
                                width: w.responsive.width,
                                height: w.responsive.height,
                                filter: w.responsive.filter,
                                transform: "translateX(" + w.responsive.x + "px) translateY(" + w.responsive.y + "px)"
                            }))) : 0 === this.$curTiles.children().length && this.$curTiles.append(ee('<div style="position: absolute;">').css({
                                width: Z.slider.width,
                                height: Z.slider.height,
                                left: -_,
                                top: -q,
                                transform: w.responsive.kbRotation + w.responsive.kbScale
                            }).append(ee("<img>").attr("src", h).css({
                                width: w.responsive.width,
                                height: w.responsive.height,
                                filter: w.responsive.filter,
                                transform: "translateX(" + w.responsive.x + "px) translateY(" + w.responsive.y + "px)"
                            })))), "transparent" === Z.transitions.curSlide.data.backgroundColor || Z.transitions.curSlide.data.$backgroundVideo.length || ("3d" === e || "2d" === e && (!0 === y || "slide" === o.transition.type || !0 === g) ? O : this.$curTiles).css("background-color", Z.transitions.curSlide.data.backgroundColor), void 0 !== Z.transitions.nextSlide.data.$background && (w = (B = Z.transitions.nextSlide.data.$background.data(Z.defaults.init.dataKey)).kenBurns[f], I.append(ee('<div style="position: absolute;">').css({
                                width: Z.slider.width,
                                height: Z.slider.height,
                                left: -_,
                                top: -q,
                                transform: "rotate(" + w.rotation + "deg) scale(" + w.scale + ")"
                            }).append(ee("<img>").attr("src", m).css({
                                width: B.responsive.width,
                                height: B.responsive.height,
                                filter: Z.transitions.nextSlide.filter.from || "none",
                                transform: "translateX(" + B.responsive.x + "px) translateY(" + B.responsive.y + "px)"
                            })))), "transparent" === Z.transitions.nextSlide.data.backgroundColor || Z.transitions.nextSlide.data.$backgroundVideo.length || I.css("background-color", Z.transitions.nextSlide.data.backgroundColor)
                        }
                        Z.transitions.slide.$wrapper.prependTo(Z.o.preferBlendMode ? Z.slider.$layersWrapper : Z.slider.$innerWrapper), Z.transitions.slide.start()
                    },
                    createCuboids: function(e, t, i, a, s, r, o, n, l, d) {
                        o = "translate3d( " + s + "px, " + r + "px, " + o + "px)";
                        0 !== n && (o += "rotateX( " + n + "deg)"), 0 !== l && (o += "rotateY( " + l + "deg)");
                        o = {
                            width: i,
                            height: a,
                            transform: o,
                            "-ms-transform": o,
                            "-webkit-transform": o
                        };
                        d && (o["transform-origin"] = d, o["-ms-transform-origin"] = d, o["-webkit-transform-origin"] = d), ee("<div>").addClass(e).css(o).appendTo(t)
                    }
                }
            },
            layers: { in : {
                    onStart: function(e) {
                        e.data(Z.defaults.init.dataKey).hover.enabled && Z.transitions.layers.hover.enable(e), Z.layers.set.dataAttribute(e, "animating-in")
                    },
                    onComplete: function(e) {
                        Z.media.functions.playIfAllowed(e), Z.layers.set.dataAttribute(e, "active")
                    }
                }, out: {
                    forced: function() {
                        var s, r, o, n, e, t, i;
                        Z.transitions._forceLayersOut && (Z.transitions._slideTimeline && (s = new J.TimelineMax({
                            paused: !0,
                            autoRemoveChildren: !0
                        }), n = [], e = Z.layers.get("current, in, static, active").add(Z.layers.get("current, out, static, active")), i = Z.layers.get("current, out, notstatic, active"), t = Z.layers.get("current, out, active"), i = ee().add(e).add(i), i.each(function() {
                            var e, t = ee(this).data(Z.defaults.init.dataKey);
                            if (t.loop._timeline && (Z.transitions._slideTimeline.remove(t.loop._timeline), t.loop._timeline.play()), t.is.static) {
                                r = [t.elements.$wrapper[0]], t.elements.$clipWrapper && (r = r.concat(t.elements.$clipWrapper[0])), t.textIn.nodes && (r = r.concat(t.textIn.nodes));
                                for (var i = 0; i < r.length; i++) n = n.concat(Z.transitions._slideTimeline.getTweensOf(r[i], !0), Z.transitions._slideTimelineAlternate.getTweensOf(r[i], !0));
                                for (var a = 0; a < n.length; a++) n[a].duration && 0 !== n[a].duration() && (o = n[a], e = o, s.add(e, 100 - e.duration() * e.progress()))
                            }
                        }), t.each(function() {
                            ee(this).data(Z.defaults.init.dataKey).should.reset = !0
                        }), s.play().seek(100), Z.transitions._slideTimeline.eventCallback("onStart", null), Z.transitions._slideTimeline.eventCallback("onComplete", null), Z.transitions._slideTimeline.eventCallback("onReverseComplete", null), Z.transitions._slideTimeline.eventCallback("onUpdate", null), Z.transitions._slideTimeline.stop().clear(), Z.transitions._slideTimelineAlternate.stop().clear()), ("prev" === Z.navigation.direction ? Z.transitions._forceLayersOutMirror : Z.transitions._forceLayersOut).play(), Z.slideshow.forceFastChange && (Z.transitions._forceLayersOut.progress(1), Z.transitions._forceLayersOutMirror.progress(1))), Z.slider.$layersWrapper.find(".ls-link").css({
                            display: "none"
                        })
                    },
                    onStart: function(e) {
                        Z.layers.set.dataAttribute(e, "animating-out")
                    },
                    onComplete: function(e) {
                        var t = e.data(Z.defaults.init.dataKey);
                        !Z.slider.state.changingSlides && t.settings.slideOut === Z.slides.current.index || Z.transitions.layers.reset(e, t), t.hover.enabled && Z.transitions.layers.hover.disable(e), Z.layers.set.dataAttribute(e, "hidden")
                    }
                }, reset: function(e, t) {
                    t.loop._timeline && (t.loop._timeline.stop().clear(), delete t.loop._timeline, J.TweenMax.set(t.elements.$loopWrapper[0], t.reset.loopWrapperOnSlideChange)), J.TweenMax.set(t.elements.$wrapper[0], t.reset.wrapperOnSlideChange), J.TweenMax.set(e[0], {
                        "-webkit-filter": "none",
                        filter: "none"
                    }), t.should.update && (t.textInNodesFrom.random = {}, t.textOutNodesTo.random = {}, Z.layers.update.data(e)), t.should.reset = !1
                }, timeline: {
                    shouldRestart: !1,
                    create: function(e) {
                        var t, i, a, s = e ? "current" : "next";
                        Z.transitions.curNext = s, Z.transitions.layers.timeline.shouldRestart = !1, Z.transitions.layers.timeline.resetStates(), Z.transitions.timelines.set("layers", function(e, t) {
                            e.pause().progress(0).kill().clear(!0), e = null
                        }), Z.transitions._slideTimeline = new J.TimelineMax({
                            paused: !0,
                            onStart: function() {
                                Z.api.hasEvent("slideTimelineDidStart") && Z.api.triggerEvent("slideTimelineDidStart", Z.api.eventData())
                            },
                            onComplete: function() {
                                Z.o.playByScroll && Z.o.playByScrollSkipSlideBreaks && ("next" === Z.slideshow.direction ? Z.transitions.layers.timeline.scrollForward(!0) : Z.transitions.layers.timeline.scrollBackwards(!0, !0))
                            },
                            onReverseComplete: function() {
                                Z.api.hasEvent("slideTimelineDidReverseComplete") && Z.api.triggerEvent("slideTimelineDidReverseComplete", Z.api.eventData()), Z.transitions.layers.timeline.shouldReplay && (Z.transitions.layers.timeline.shouldRestart = !1, Z.transitions._slideTimeline.play()), Z.o.playByScroll && Z.o.playByScrollSkipSlideBreaks && Z.transitions.layers.timeline.scrollBackwards(!0, !1)
                            },
                            onUpdate: function(e) {
                                Z.api.hasEvent("slideTimelineDidUpdate") && Z.api.triggerEvent("slideTimelineDidUpdate", e)
                            },
                            onUpdateParams: ["{self}"]
                        }), Z.transitions._slideTimelineAlternate = new J.TimelineMax({
                            paused: !0
                        }), this.totalDuration = 0, this.progress = 1, Z.transitions.timelines.set("prevforce", function(e, t) {
                            e.progress(1).kill().clear(!0), e = null
                        }), Z.transitions._forceLayersOut && (Z.transitions._forceLayersOutPrevious = Z.transitions._forceLayersOut), Z.transitions._forceLayersOutMirror && (Z.transitions._forceLayersOutMirrorPrevious = Z.transitions._forceLayersOutMirror), Z.transitions._forceLayersOut = new J.TimelineMax({
                            paused: !0,
                            autoRemoveChildren: !0
                        }), Z.transitions._forceLayersOutMirror = new J.TimelineMax({
                            paused: !0,
                            autoRemoveChildren: !0
                        }), t = Z.layers.get(s + ", in, notactive"), i = Z.layers.get(s + ", out, notstatic").add(Z.layers.get(s + ", out, active, static")), e = Z.layers.get(s + ", in, bgonly, notactive"), a = ee().add(t).add(i).add(e), this.addLayers(t, "in", Z.transitions._slideTimeline, Z.transitions._forceLayersOut, Z.transitions._slideTimelineAlternate, Z.transitions._forceLayersOutMirror), this.addLayers(i, "out", Z.transitions._slideTimeline, Z.transitions._forceLayersOut, Z.transitions._slideTimelineAlternate, Z.transitions._forceLayersOutMirror), Z.slides[s].data && -1 !== Z.slides[s].data.duration && Z.slides[s].data.duration < this.totalDuration ? (this.progress = Z.slides[s].data.duration / this.totalDuration, Z.debugMode && Z.debug.add("warn", "slideTimeline.duration", [Z.slides[s].data.duration, this.totalDuration])) : Z.transitions._slideTimeline.duration() > this.totalDuration && (this.progress = this.totalDuration / Z.transitions._slideTimeline.duration()), -1 === Z.slides[s].data.duration ? (Z.o.slideDuration && ee.isNumeric(Z.o.slideDuration) && -1 < Z.o.slideDuration ? this.totalDuration = Z.o.slideDuration / 1e3 : 0 === this.totalDuration && (this.totalDuration = Z.o.slideDurationWithoutLayers / 1e3), Z.o.inLayerPreview && (Z.o.hasInfiniteLoop && "loop-transition" === Z.o.layerPreviewPresetType ? this.totalDuration += 5 : "ending-transition" === Z.o.layerPreviewPresetType ? this.totalDuration += .25 : "hover-transition" !== Z.o.layerPreviewPresetType && (this.totalDuration += .5)), Z.slides[s].data.duration = this.totalDuration, Z.slides[Z.slides[s].index].data.duration = this.totalDuration) : this.totalDuration = Z.slides[s].data.duration, this.addLayers(e, "in", Z.transitions._slideTimeline, Z.transitions._forceLayersOut, Z.transitions._slideTimelineAlternate), !0 === Z.transitions.layers.timeline.shouldRestart && Z.debugMode && Z.debug.add("warn", "slideTimeline.restart", Z.o.allowRestartOnResize ? "enabled" : "disabled");
                        for (var r, o = 0; o < a.length; o++) ee(a[o]).data(Z.defaults.init.dataKey).parallax.enabled && ee(a[o]).data(Z.defaults.init.dataKey).elements.$parallaxWrapper.attr("data-ls-parallax", "active");
                        Z.transitions.layers.parallax.trigger(), Z.transitions.layers.scroll.reset(), Z.transitions.layers.scroll.trigger(), Z.api.hasEvent("slideTimelineDidCreate") && Z.api.triggerEvent("slideTimelineDidCreate", {
                            slideTimeline: Z.transitions._slideTimeline,
                            layersOnSlideTimeline: a,
                            slideTimelineDuration: this.totalDuration
                        }), Z.transitions.timers.create(), Z.transitions.timers.bar._transition && Z.transitions._slideTimeline.add(Z.transitions.timers.bar._transition.play(), 0), Z.transitions.timers.circle._transition && Z.transitions._slideTimeline.add(Z.transitions.timers.circle._transition.play(), 0), Z.transitions.timers.slidebar._transition && Z.transitions._slideTimeline.add(Z.transitions.timers.slidebar._transition.play(), 0), Z.transitions._slideTimeline.call(function() {
                            if (!Z.transitions._slideTimeline.reversed()) {
                                var e;
                                if (Z.api.hasEvent("slideTimelineDidComplete"))
                                    if (Z.o.inLayerPreview && Z.o.hasInfiniteLoop && Z.layers.get("current, in").each(function() {
                                            (e = ee(this).data(Z.defaults.init.dataKey)).loop && e.loop._timeline && e.loop._timeline.stop().progress(0)
                                        }), !1 === Z.api.triggerEvent("slideTimelineDidComplete", Z.api.eventData())) return;
                                Z.functions.setStates(Z.transitions.layers.timeline, {
                                    finished: !0
                                }), !Z.slideshow.isPaused() && Z.slideshow.state.running ? Z.slideshow.changeTo(Z.slides.next.index) : Z.slideshow.state.pausedByLastCycle && Z.transitions.timers.reverse()
                            }
                        }, [], this, Z.slides[s].data.duration), Z.slides.next.data.$link && Z.slides.next.data.$link.css({
                            display: "block"
                        }), (!Z.o.startInViewport || "inside" !== Z.slider.positionToViewport && !Z.o.playByScrollStart) && Z.o.startInViewport || !(Z.slider.isPopup && Z.slider.state.popupIsVisible && Z.slider.state.popupShouldStart) && Z.slider.isPopup || (Z.o.pauseLayers && Z.slideshow.isPaused() && Z.transitions._slideTimeline.timeScale(0), Z.transitions.layers.timeline.play(), Z.o.playByScroll && "up" === Z.device.scroll.directionAtSlideTransitionStart && Z.transitions._slideTimeline.progress(1)), Z.transitions._slideTimelineAlternate.play(), $.trigger("mouseleave.globalhover" + B), $.off("mouseenter.globalhover" + B + " mouseleave.globalhover" + B + " mousemove.globalhover" + B), Z.slides[s].data.globalhover && (r = Z.layers.get(s + ",in,notactive").add(Z.layers.get("static,active")), $.on("mouseenter.globalhover" + B, function() {
                            r.each(function() {
                                Z.transitions.layers.hover.mouseEnter(ee(this), ee(this).data(Z.defaults.init.dataKey))
                            })
                        }), $.on("mouseleave.globalhover" + B, function() {
                            r.each(function() {
                                Z.transitions.layers.hover.mouseLeave(ee(this), ee(this).data(Z.defaults.init.dataKey))
                            })
                        }), $.on("mousemove.globalhover" + B, function() {
                            r.each(function() {
                                Z.transitions.layers.hover.mouseMove(ee(this), ee(this).data(Z.defaults.init.dataKey))
                            })
                        }))
                    },
                    prepare: function() {
                        Z.slides.next.data.overflow && "hidden" !== Z.slides.next.data.overflow ? (Z.slider.$layersWrapper.addClass("ls-visible"), Z.slider.$slideBGWrapper.addClass("ls-visible")) : (Z.slider.$layersWrapper.removeClass("ls-visible"), Z.slider.$slideBGWrapper.removeClass("ls-visible")), this.create()
                    },
                    getTiming: function(e, t, i, a) {
                        if ("number" == typeof t) return t;
                        t = t.toLowerCase();
                        var s, r, o, n, l, d = Z.defaults.layer.timelineHierarchy,
                            c = 0;
                        if (-1 !== t.indexOf("*") && (l = "*"), -1 !== t.indexOf("/") && (l = "/"), -1 !== t.indexOf("+") && (l = "+"), -1 !== t.indexOf("-") && (l = "-"), l)
                            if (n = t.split(l), s = ee.trim(n[0]), o = parseInt(ee.trim(n[1])), d[s] && -1 !== d[i][1].indexOf(d[s][0])) {
                                if (!e.timeline[s] && 1 < d[s][0]) {
                                    var u, p, h = d[s][0] - 1 || 1;
                                    for (p in d) d[p][0] === h && (u = p);
                                    s = u
                                }
                                if (r = "number" == typeof e.timeline[s] ? e.timeline[s] : e.timeline[s](e), a) c = o / 1e3;
                                else switch (l) {
                                    case "*":
                                        c = r * o;
                                        break;
                                    case "/":
                                        c = r / o;
                                        break;
                                    case "+":
                                        c = r + o / 1e3;
                                        break;
                                    case "-":
                                        c = r - o / 1e3
                                }
                            } else Z.debugMode && (d[s] || Z.debug.add("warn", "layerTransition.timing1", s), -1 === d[i][1].indexOf(d[s][0]) && Z.debug.add("warn", "layerTransition.timing3", [s, d[s], i, d[i]])), "+" !== l && !a || (c = o / 1e3);
                        else d[s = ee.trim(t)] && -1 !== d[i][1].indexOf(d[s][0]) ? c = a ? 0 : "number" == typeof e.timeline[s] ? e.timeline[s] : e.timeline[s](e) : Z.debugMode && (d[s] ? -1 === d[i][1].indexOf(d[s][0]) && Z.debug.add("warn", "layerTransition.timing3", [s, d[s], i, d[i]]) : Z.debug.add("warn", "layerTransition.timing1", s));
                        return (c != c || c < 0) && (Z.debugMode && Z.debug.add("warn", "layerTransition.timing2", [i, s, c]), c = 0), c
                    },
                    addLayers: function(e, t, i, a, s, r) {
                        for (var o = 0, n = e.length; o < n; o++) {
                            var l, d, c, u = e[o],
                                p = ee(u),
                                h = p.data(Z.defaults.init.dataKey),
                                m = h.elements.$wrapper,
                                f = h.elements.$clipWrapper,
                                g = h.elements.$loopWrapper,
                                y = h.elements.$parallaxWrapper,
                                v = (h.elements.$scrollWrapper, h.elements.$scrollTransformWrapper, h.settings.skipViewport && Z.slideshow.state.changed < 1 ? s : i),
                                b = "loop" == h.settings.skipViewport && Z.slideshow.state.changed < 1 ? s : i,
                                w = ee.extend(!0, {}, h.inLayerFrom),
                                S = w.css,
                                x = ee.extend({}, h.inLayerShouldBeConverted),
                                T = ee.extend(!0, {}, h.outLayerTo),
                                C = T.css,
                                k = ee.extend({}, h.outLayerShouldBeConverted),
                                O = ee.extend(!0, {}, h.textInNodesFrom),
                                P = ee.extend(!0, {}, h.textInShouldBeConverted),
                                L = ee.extend(!0, {}, h.textOutNodesTo),
                                I = ee.extend(!0, {}, h.textOutShouldBeConverted);
                            if (h.should.reset && Z.transitions.layers.reset(p, h), p.hasClass("ls-bg")) h.kenBurns.zoom && i.fromTo(p.closest(".ls-bg-wrap"), Z.transitions.nextSlide.data.duration + Z.transitions.nextSlide.data.calculatedTimeShift, {
                                autoCSS: !1,
                                css: h.kenBurns.from
                            }, {
                                autoCSS: !1,
                                css: h.kenBurns.to,
                                ease: J.Quad.easeInOut
                            }, -Z.transitions.nextSlide.data.calculatedTimeShift), ee.isEmptyObject(h.filter.values.bgFrom) && ee.isEmptyObject(h.filter.values.bgTo) || (h.filter.transitions.bg || (h.filter.transitions.bg = Z.transitions.layers.filters.createTransition(h, "bg", h.filter.values.bgFrom, h.filter.values.bgTo)), v.to([{
                                p: 0
                            }, u], Z.transitions.nextSlide.data.duration, {
                                p: 1,
                                autoCSS: !1,
                                ease: J.Sine.easeInOut,
                                onUpdate: Z.transitions.layers.filters.animate,
                                onUpdateParams: ["{self}", h.filter.transitions.bg]
                            }, 0));
                            else switch (t) {
                                case "in":
                                    if (h.in.enabled && (h.settings.timelineIsCalculated || ("number" != typeof h.in.startAt && (h.in.startAt = 0), h.timeline.transitioninstart = h.in.startAt, h.timeline.transitioninend = h.timeline.transitioninstart + h.in.duration), Z.resize.performTransformOperations(h.inLayerToCSS, S), h.in.mirror && "prev" === Z.navigation.direction && Z.resize.mirrorTransitionProperties({
                                            transitionProperties: S,
                                            transitionPropertiesShouldBeConverted: x,
                                            transitionType: "normal",
                                            mirrorProperties: h.in.mirror
                                        }), Z.resize.transformProperties(p, h, S, x), Z.resize.styleProperties(h, h.inLayerStyleFromCSS, h.inLayerStyleShouldBeConvertedFrom), Z.resize.styleProperties(h, h.inLayerStyleToCSS, h.inLayerStyleShouldBeConvertedTo), S.transformPerspective = h.transformPerspective.layer * h.settings.calculatedratio, h.clip.enabled && (h.original.clip || (h.original.clip = h.clip.min, h.original.clipShouldBeConverted = !0), h.inClipShouldBeConverted.clip ? (h.inClipFromCSS.clip = Z.resize.clip(p, h, h.inClipShouldBeConverted.clip, !0), h.inClipToCSS.clip = Z.resize.clip(p, h, h.original.clip, h.original.clipShouldBeConverted), v.fromTo(f[0], h.in.duration, h.inClipFrom, h.inClipTo, h.timeline.transitioninstart)) : J.TweenMax.set(f[0], {
                                            clip: Z.resize.clip(p, h, h.original.clip, h.original.clipShouldBeConverted)
                                        }), Z.transitions.layers.timeline.shouldRestart = !0), ee.isEmptyObject(h.filter.values.in) ? ee.isEmptyObject(h.filter.values.out) || p.css("filter", h.original.filter) : (h.filter.transitions.in || (h.filter.transitions.in = Z.transitions.layers.filters.createTransition(h, "in", h.filter.values.in, h.filter.values.style)), v.to([{
                                            p: 0
                                        }, u], h.in.duration, {
                                            p: 1,
                                            autoCSS: !1,
                                            ease: h.inLayerTo.ease,
                                            onUpdate: Z.transitions.layers.filters.animate,
                                            onUpdateParams: ["{self}", h.filter.transitions.in]
                                        }, h.timeline.transitioninstart)), v.fromTo(m[0], h.in.duration, w, h.inLayerTo, h.timeline.transitioninstart), v.fromTo(u, h.in.duration, h.inLayerStyleFrom, h.inLayerStyleTo, h.timeline.transitioninstart)), h.is.textLayer && ((h.textIn.type || h.textOut.type) && Z.transitions.layers.splitType.resetNodes(p, h), h.textIn.enabled && ($ = !(!h.textIn.mirror || "prev" !== Z.navigation.direction), h.in.enabled || v.to(m[0], 0, ee.extend(!0, {}, h.inLayerTo, h.init.wrapper), h.timeline.textinstart), d = Z.transitions.layers.splitType.setNodesSequence(h.textIn.type.split("_"), h.textIn.ns), h.textIn.nodes = $ ? d[1] : d[0], $ && Z.resize.mirrorTransitionProperties({
                                            transitionProperties: O,
                                            transitionPropertiesShouldBeConverted: P,
                                            transitionType: "text",
                                            mirrorProperties: h.textIn.mirror
                                        }), Z.resize.transformProperties(p, h, O, P, !1, h.textIn.nodes), O.transformPerspective = h.transformPerspective.text * h.settings.calculatedratio, ee.isEmptyObject(P.random) || Z.transitions.layers.splitType.setRandomProperties(h, P.random, O, "In"), ee.isEmptyObject(O.random) || Z.transitions.layers.splitType.setRandomProperties(h, O.random, O, "In"), delete O.random, h.settings.timelineIsCalculated || (h.timeline.textinstart = this.getTiming(h, h.textIn.startAt, "textinstart"), h.timeline.textinend = h.timeline.textinstart + (h.textIn.nodes.length - 1) * h.textIn.shiftNodes + h.textIn.duration), O.color ? h.textInNodesToCSS.color = h.original.color : h.textOutNodesTo.color && (O.color = h.original.color), v.set(u, h.textIn.layerStyle, h.timeline.textinstart), window.getSelection && Z.browser.isSafari && v.addCallback(function(e) {
                                            window.getSelection().setBaseAndExtent(e, 0, e, 1e3), window.getSelection().removeAllRanges()
                                        }, h.timeline.textinstart + .001, [u]), v.staggerFromTo(h.textIn.nodes, h.textIn.duration, O, h.textInNodesTo, h.textIn.shiftNodes, h.timeline.textinstart, function(e) {
                                            Z.transitions.layers.in.onComplete(e)
                                        }, [p]))), h.is.keyframe && Z.o.playByScroll && i.addPause(h.timeline.allinend(), function() {
                                            setTimeout(function() {
                                                delete Z.timeouts.scroll, Z.transitions.layers.timeline.timeScaleModifier = 0, Z.device.scroll.timeout = 250
                                            }, 500)
                                        }), h.parallax.enabled && "auto" == h.parallax.event) {
                                        Z.transitions.layers.parallax.auto();
                                        var $ = new J.TimelineMax({
                                                paused: !0
                                            }),
                                            B = {
                                                repeat: -1 == h.parallax.count ? -1 : h.parallax.count - 1,
                                                ease: Linear.easeNone
                                            };
                                        switch (h.settings.timelineIsCalculated && !h.is.static || (h.timeline.autoparallaxstart = this.getTiming(h, h.parallax.startAt, "autoparallaxstart"), h.timeline.autoparallaxend = -1 !== h.parallax.count && h.timeline.autoparallaxstart + h.parallax.duration * h.parallax.count), h.parallax._timeline = $, h.parallax.dummy = {
                                            x: 0,
                                            y: -10
                                        }, h.parallax.path) {
                                            default:
                                                case "circle":
                                                B.bezier = {
                                                curviness: 1.5,
                                                values: [{
                                                    x: 10,
                                                    y: 0
                                                }, {
                                                    x: 0,
                                                    y: 10
                                                }, {
                                                    x: -10,
                                                    y: 0
                                                }, {
                                                    x: 0,
                                                    y: -10
                                                }]
                                            };
                                            break;
                                            case "oval-h":
                                                    B.bezier = {
                                                    type: "thru",
                                                    curviness: 1,
                                                    values: [{
                                                        x: 20,
                                                        y: 0
                                                    }, {
                                                        x: 0,
                                                        y: 10
                                                    }, {
                                                        x: -20,
                                                        y: 0
                                                    }, {
                                                        x: 0,
                                                        y: -10
                                                    }]
                                                };
                                                break;
                                            case "oval-v":
                                                    h.parallax.dummy = {
                                                    x: 0,
                                                    y: -20
                                                },
                                                B.bezier = {
                                                    type: "thru",
                                                    curviness: 1,
                                                    values: [{
                                                        x: 10,
                                                        y: 0
                                                    }, {
                                                        x: 0,
                                                        y: 20
                                                    }, {
                                                        x: -10,
                                                        y: 0
                                                    }, {
                                                        x: 0,
                                                        y: -20
                                                    }]
                                                };
                                                break;
                                            case "infinity":
                                                    h.parallax.dummy = {
                                                    x: 0,
                                                    y: 0
                                                },
                                                B.bezier = {
                                                    type: "thru",
                                                    curviness: 1,
                                                    values: [{
                                                        x: 20,
                                                        y: -10
                                                    }, {
                                                        x: 40,
                                                        y: 0
                                                    }, {
                                                        x: 20,
                                                        y: 10
                                                    }, {
                                                        x: 0,
                                                        y: 0
                                                    }, {
                                                        x: -20,
                                                        y: -10
                                                    }, {
                                                        x: -40,
                                                        y: 0
                                                    }, {
                                                        x: -20,
                                                        y: 10
                                                    }, {
                                                        x: 0,
                                                        y: 0
                                                    }]
                                                };
                                                break;
                                            case "linear-h":
                                                    h.parallax.dummy = {
                                                    x: -10,
                                                    y: 0
                                                },
                                                B.x = 10,
                                                B.ease = Quad.easeInOut,
                                                B.yoyo = !0,
                                                B.repeat = -1 == h.parallax.count ? -1 : 2 * h.parallax.count - 1;
                                                break;
                                            case "linear-v":
                                                    h.parallax.dummy = {
                                                    x: 0,
                                                    y: -10
                                                },
                                                B.y = 10,
                                                B.ease = Quad.easeInOut,
                                                B.yoyo = !0,
                                                B.repeat = -1 == h.parallax.count ? -1 : 2 * h.parallax.count - 1
                                        }
                                        B.onUpdate = function(e, t, i, a, s, r, o) {
                                            J.TweenMax.set(i, {
                                                x: -t.x * (a / 50) * parseInt(s),
                                                y: -t.y * (a / 50) * parseInt(s),
                                                rotationX: "3d" == r ? t.y / (100 / o) : 0,
                                                rotationY: "3d" == r ? -t.x / (100 / o) : 0
                                            })
                                        }, B.onUpdateParams = ["{self}", h.parallax.dummy, y[0], h.parallax.distance, h.parallax.level, h.parallax.type, h.parallax.rotation], $.to(h.parallax.dummy, -1 == h.parallax.path.indexOf("linear") ? h.parallax.duration : h.parallax.duration / 2, B), i.add($, h.timeline.autoparallaxstart), $.play()
                                    }
                                    h.loop.enabled && (c = new J.TimelineMax({
                                        repeat: h.loop.repeat,
                                        repeatDelay: h.loop.repeatDelay,
                                        yoyo: h.loop.yoyo,
                                        paused: !0
                                    }), h.settings.timelineIsCalculated && !h.is.static || (h.timeline.loopstart = this.getTiming(h, h.loop.startAt, "loopstart"), h.timeline.loopend = -1 !== h.loop.count && h.timeline.loopstart + (h.loop.repeat + 1) * h.loop.duration + h.loop.repeat * h.loop.repeatDelay), h.loop._timeline = c, Z.resize.transformProperties(p, h, h.loopToCSS, {
                                        x: h.loopLayerShouldBeConverted.x,
                                        y: h.loopLayerShouldBeConverted.y
                                    }), (h.loopToCSS.x && 0 !== h.loopToCSS.x || h.loopToCSS.y && 0 !== h.loopToCSS.y) && (Z.transitions.layers.timeline.shouldRestart = !0), h.loopFromCSS.transformOrigin = Z.functions.convert.transformOrigin(h.loopLayerShouldBeConverted.transformOrigin, p, h, p.data(Z.defaults.init.dataKey).elements.$outerStyleWrapper), h.loopFromCSS.transformPerspective = h.transformPerspective.loop * h.settings.calculatedratio, ee.isEmptyObject(h.filter.values.loop) || (h.filter.transitions.loop || (h.filter.transitions.loop = Z.transitions.layers.filters.createTransition(h, "loop", ee.isEmptyObject(h.filter.values.afterIn) ? h.filter.values.style : h.filter.values.afterIn, h.filter.values.loop)), c.to([{
                                        p: 0
                                    }, u], h.loop.duration, {
                                        p: 1,
                                        autoCSS: !1,
                                        ease: h.loopTo.ease,
                                        onUpdate: Z.transitions.layers.filters.animate,
                                        onUpdateParams: ["{self}", h.filter.transitions.loop]
                                    }, 0)), c.fromTo(g[0], h.loop.duration, h.loopFrom, h.loopTo, 0), h.loopClipShouldBeConverted.clip && (h.loopClipToCSS.clip = Z.resize.clip(p, h, h.loopClipShouldBeConverted.clip, !0), c.to(f[0], h.loop.duration, h.loopClipTo, 0), Z.transitions.layers.timeline.shouldRestart = !0), -1 !== h.loop.repeat && ("looplayers" === Z.o.pauseOnHover || Z.gui.timers.slidebar.$element || Z.o.playByScroll) ? (b.add(c, h.timeline.loopstart), c.play()) : b.addCallback(function(e) {
                                        e.play()
                                    }, h.timeline.loopstart, [c])), h.is.static && (h.timeline.staticfrom = h.timeline.transitioninend, h.timeline.staticto = "100%", h.settings.timelineIsCalculated || (l = Math.max(h.timeline.allinandloopend(), 0), this.totalDuration = Math.max(this.totalDuration, l)));
                                    break;
                                case "out":
                                    h.is.textLayer && h.textOut.enabled && (c = Z.transitions.layers.splitType.setNodesSequence(h.textOut.type.split("_"), h.textOut.ns), h.textOut.nodes = c[0], Z.resize.transformProperties(p, h, h.textOutNodesTo, h.textOutShouldBeConverted, h.textOutNodesFrom, h.textOut.nodes), h.textOut.mirror && (h.textOut.nodesMirror = c[1], Z.resize.mirrorTransitionProperties({
                                        transitionProperties: L,
                                        transitionPropertiesShouldBeConverted: I,
                                        transitionType: "text",
                                        mirrorProperties: h.textOut.mirror
                                    }), Z.resize.transformProperties(p, h, L, I, h.textOutNodesFrom, h.textOut.nodes)), h.textOutNodesFrom.transformPerspective = h.transformPerspective.text * h.settings.calculatedratio, ee.isEmptyObject(h.textOutShouldBeConverted.random) || Z.transitions.layers.splitType.setRandomProperties(h, h.textOutShouldBeConverted.random, h.textOutNodesTo, "Out"), ee.isEmptyObject(h.textOutNodesTo.random) || Z.transitions.layers.splitType.setRandomProperties(h, h.textOutNodesTo.random, h.textOutNodesTo, "Out"), delete h.textOutNodesTo.random, h.textOut.mirror && (ee.isEmptyObject(I.random) || Z.transitions.layers.splitType.setRandomProperties(h, I.random, L, "Out"), ee.isEmptyObject(L.random) || Z.transitions.layers.splitType.setRandomProperties(h, L.random, L, "Out"), delete L.random), h.settings.timelineIsCalculated || (h.timeline.textoutstart = this.getTiming(h, h.textOut.startAt, "textoutstart"), h.timeline.textoutend = h.timeline.textoutstart + (h.textOut.nodes.length - 1) * h.textOut.shiftNodes + h.textOut.duration), h.clip.enabled && (void 0 === h.outClipShouldBeConverted.clip && i.to(f[0], 0, {
                                        immediateRender: !1,
                                        css: {
                                            clip: Z.resize.clip(p, h, h.clip.max)
                                        }
                                    }, h.timeline.textoutstart), Z.transitions.layers.timeline.shouldRestart = !0), h.textOutNodesTo.color && (h.textOutNodesFrom.color = h.original.color), -1 !== h.textOut.startAt.indexOf("slidechangeonly") && (!h.is.static || h.is.static && h.settings.slideOut === Z.slides.next.index) ? (a.set(u, h.textOut.layerStyle, 0), r.set(u, h.textOut.layerStyle, 0), (c = new J.TimelineMax).staggerFromTo(h.textOut.nodes, h.textOut.duration, h.textOutNodesFrom, h.textOutNodesTo, h.textOut.shiftNodes, 0), c.timeScale(c.duration() / Z.o.forceLayersOutDuration), a.add(c, 0), a.to(m[0], 0, h.reset.wrapperOnTimelineEnd, Z.o.forceLayersOutDuration), (c = new J.TimelineMax).staggerFromTo(h.textOut.nodesMirror, h.textOut.duration, h.textOutNodesFrom, L, h.textOut.shiftNodes, 0), c.timeScale(c.duration() / Z.o.forceLayersOutDuration), r.add(c, 0)) : (i.set(u, h.textOut.layerStyle, h.timeline.textoutstart), i.staggerFromTo(h.textOut.nodes, h.textOut.duration, h.textOutNodesFrom, h.textOutNodesTo, h.textOut.shiftNodes, h.timeline.textoutstart), a.to(m[0], Z.o.forceLayersOutDuration, {
                                        opacity: 0
                                    }, 0), r.to(m[0], Z.o.forceLayersOutDuration, {
                                        opacity: 0
                                    }, 0), a.to(m[0], 0, h.reset.wrapperOnTimelineEnd, Z.o.forceLayersOutDuration)), r.to(m[0], 0, h.reset.wrapperOnTimelineEnd, Z.o.forceLayersOutDuration)), h.out.enabled && (Z.resize.performTransformOperations(h.inLayerToCSS, h.outLayerToCSS), Z.resize.transformProperties(p, h, h.outLayerToCSS, h.outLayerShouldBeConverted, h.outLayerFromCSS), Z.resize.styleProperties(h, h.outLayerStyleFromCSS, h.outLayerStyleShouldBeConvertedFrom), Z.resize.styleProperties(h, h.outLayerStyleToCSS, h.outLayerStyleShouldBeConvertedTo), h.outLayerFromCSS.transformPerspective = h.transformPerspective.layer * h.settings.calculatedratio, h.out.mirror && (Z.resize.performTransformOperations(h.inLayerToCSS, C), Z.resize.mirrorTransitionProperties({
                                        transitionProperties: C,
                                        transitionPropertiesShouldBeConverted: k,
                                        transitionType: "normal",
                                        mirrorProperties: h.out.mirror
                                    }), Z.resize.transformProperties(p, h, C, k, h.outLayerFromCSS)), "slidechangeonly" !== h.out.startAt ? (h.settings.timelineIsCalculated && !h.is.static || (h.is.static ? (h.timeline.staticfrom = 0, h.timeline.transitionoutstart = this.getTiming(h, h.out.startAt, "transitionoutstart", !0), h.timeline.staticto = h.timeline.transitionoutstart) : h.timeline.transitionoutstart = Math.max(this.getTiming(h, h.out.startAt, "transitionoutstart"), h.timeline.transitioninend), h.timeline.transitionoutend = h.timeline.transitionoutstart + h.out.duration), h.clip.enabled && (void 0 === h.outClipShouldBeConverted.clip ? i.to(f[0], 0, {
                                        immediateRender: !1,
                                        css: {
                                            clip: Z.resize.clip(p, h, h.clip.max)
                                        }
                                    }, h.timeline.transitionoutstart) : (h.outClipToCSS.clip = Z.resize.clip(p, h, h.outClipShouldBeConverted.clip, !0), i.to(f[0], h.out.duration, h.outClipTo, h.timeline.transitionoutstart)), Z.transitions.layers.timeline.shouldRestart = !0), ee.isEmptyObject(h.filter.values.out) || (h.filter.transitions.out || (h.filter.transitions.out = Z.transitions.layers.filters.createTransition(h, "out", ee.isEmptyObject(h.filter.values.afterLoop) ? ee.isEmptyObject(h.filter.values.afterIn) ? h.filter.values.style : h.filter.values.afterIn : h.filter.values.afterLoop, h.filter.values.out)), i.to([{
                                        p: 0
                                    }, u], h.out.duration, {
                                        p: 1,
                                        autoCSS: !1,
                                        ease: h.outLayerTo.ease,
                                        onUpdate: Z.transitions.layers.filters.animate,
                                        onUpdateParams: ["{self}", h.filter.transitions.out]
                                    }, h.timeline.transitionoutstart)), i.fromTo(m[0], h.out.duration, h.outLayerFrom, h.outLayerTo, h.timeline.transitionoutstart), i.fromTo(u, h.out.duration, h.outLayerStyleFrom, h.outLayerStyleTo, h.timeline.transitionoutstart), i.fromTo(m[0], 0, h.init.wrapper, h.reset.wrapperOnTimelineEnd, h.timeline.transitionoutend)) : (h.timeline.staticfrom = 0, h.timeline.staticto = "100%"), (!h.is.static || h.is.static && h.settings.slideOut === Z.slides.next.index) && (a.fromTo(m[0], Z.o.forceLayersOutDuration, h.outLayerFrom, h.outLayerTo, 0), a.fromTo(u, Z.o.forceLayersOutDuration, h.outLayerStyleFrom, h.outLayerStyleTo, 0), r.fromTo(m[0], Z.o.forceLayersOutDuration, h.outLayerFrom, h.out.mirror ? T : h.outLayerTo, 0), r.fromTo(u, Z.o.forceLayersOutDuration, h.outLayerStyleFrom, h.outLayerStyleTo, 0), h.clip.enabled && void 0 !== h.outClipShouldBeConverted.clip && (h.outClipToCSS.clip = Z.resize.clip(p, h, h.outClipShouldBeConverted.clip, !0), a.to(f[0], Z.o.forceLayersOutDuration, h.outClipTo, 0), r.to(f[0], Z.o.forceLayersOutDuration, h.outClipTo, 0)))), l = Math.max(h.timeline.alloutandloopend(), 0), this.totalDuration = Math.max(this.totalDuration, l), h.settings.timelineIsCalculated = !0
                            }
                        }
                    },
                    play: function() {
                        Z.transitions._slideTimeline && (Z.transitions._slideTimeline.play(), Z.functions.setStates(this, {
                            started: !0,
                            running: !0,
                            stopped: !1,
                            paused: !1
                        }))
                    },
                    pause: function(e) {
                        e = ee.isNumeric(e) ? e : .75;
                        Z.transitions._slideTimeline && (J.TweenMax.to(Z.transitions._slideTimeline, e, {
                            timeScale: 0
                        }), Z.functions.setStates(this, {
                            paused: !0,
                            stopped: !1
                        }))
                    },
                    resume: function() {
                        Z.transitions._slideTimeline && (J.TweenMax.to(Z.transitions._slideTimeline, .75, {
                            timeScale: 1
                        }), Z.functions.setStates(this, {
                            paused: !1,
                            stopped: !1
                        }))
                    },
                    reverse: function() {
                        Z.transitions._slideTimeline && Z.transitions._slideTimeline.reverse()
                    },
                    scrollForward: function(e) {
                        e || (this.play(), this.modifyTimeScale()), Z.transitions._slideTimeline && (Z.slider.isBusy() || 0 !== Z.transitions._slideTimeline.totalDuration() && 1 !== Z.transitions._slideTimeline.progress() || "down" !== Z.device.scroll.direction || (Z.slideshow.direction = "next", (e = Z.slideshow.sequence.normalized).indexOf(Z.slides.current.index) === e.length - 1 ? (Z.slider.positionToViewport = "under", Z.device.scroll.enable(), Z.slideshow.direction = "prev") : Z.navigation.next()))
                    },
                    scrollBackwards: function(e, t) {
                        e && !t || (this.reverse(), this.modifyTimeScale()), Z.transitions._slideTimeline && (Z.slider.isBusy() || 0 !== Z.transitions._slideTimeline.totalDuration() && 0 !== Z.transitions._slideTimeline.progress() || "up" !== Z.device.scroll.direction || (Z.slideshow.direction = "prev", 0 === Z.slideshow.sequence.normalized.indexOf(Z.slides.current.index) ? (Z.slider.positionToViewport = "over", Z.device.scroll.enable(), Z.slideshow.direction = "next") : Z.navigation.prev()))
                    },
                    modifyTimeScale: function() {
                        Z.transitions._slideTimeline && J.TweenMax.to(Z.transitions._slideTimeline, .25, {
                            timeScale: 1 + this.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." + B, function() {
                            Z.transitions.layers.hover.mouseEnter(e, t)
                        }), t.elements.$wrapper.on("mouseleave." + B, function() {
                            Z.transitions.layers.hover.mouseLeave(e, t)
                        }), t.elements.$wrapper.on("mousemove." + B, function() {
                            Z.transitions.layers.hover.mouseMove(e, t)
                        })
                    },
                    createTimeline: function(e, t) {
                        var i, a, s;
                        t.hover._timeline = new J.TimelineMax({
                            paused: !0,
                            onReverseComplete: function(e, t) {
                                t.hover._timeline._reversed && (t.hover._timeline.stop().clear(), delete t.hover._timeline)
                            },
                            onReverseCompleteParams: [e, t]
                        }), Z.resize.transformProperties(e, t, t.hoverToCSS, t.hoverShouldBeConverted, t.hoverFromCSS), Z.resize.styleProperties(t, t.hoverToCSS, t.hoverShouldBeConverted), t.hoverFromCSS.transformPerspective = t.transformPerspective.hover * t.settings.calculatedratio, t.hover._tween = J.TweenMax.fromTo(e[0], t.hover.durationIn, t.hoverFrom, t.hoverTo), t.hover._timeline.add(t.hover._tween, 0), e.next().is(".ls-layer-link") ? (i = e.next(), a = ee.extend(!0, {}, t.hoverFrom, {
                            css: {
                                opacity: 1,
                                color: "transparent",
                                background: "transparent",
                                z: 0
                            }
                        }), s = ee.extend(!0, {}, t.hoverTo, {
                            css: {
                                opacity: 1,
                                color: "transparent",
                                background: "transparent",
                                z: 0
                            }
                        }), t.hover._linkTween = J.TweenMax.fromTo(i[0], t.hover.durationIn, a, s), t.hover._timeline.add(t.hover._linkTween, 0)) : t.hover._linkTween = null, t.hover.alwaysOnTop && (s = {
                            zIndex: 9999
                        }, Z.browser.isSafari && (s.transform = "translateZ(999999px)"), t.hover._timeline.to(t.elements.$outerWrapper[0], t.hover.durationIn, {
                            autoCSS: !1,
                            css: s
                        }, 0)), t.hover.reverseTimeScale = t.hover.durationIn / t.hover.durationOut == 1 ? 1 : t.hover.durationIn / t.hover.durationOut, this.hoverIn(e, t)
                    },
                    mouseEnter: function(e, t) {
                        "1" === e.attr("data-ls-canhover") && (e.attr("data-ls-hovered", 1), t.elements.$wrapper.off("mousemove." + B), 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",
                        path: "circle",
                        direction: "clockwise",
                        duration: 5,
                        count: -1,
                        startAt: "slidestart",
                        x: !0,
                        y: !0,
                        rotation: 10,
                        distance: 10,
                        durationMove: 1.5,
                        durationLeave: 1.2,
                        transformOrigin: "slidercenter slidermiddle 0",
                        transformPerspective: 500
                    },
                    defaults: {
                        scrollModifier: 5,
                        centerLayers: "center",
                        centerDegree: 40,
                        sensitive: 10
                    },
                    state: {
                        enabled: !1,
                        ready: !1
                    },
                    wrappers: {
                        cursor: {
                            $2d: ee(),
                            $3d: ee()
                        },
                        scroll: {
                            $2d: ee(),
                            $3d: ee()
                        },
                        auto: {
                            $2d: ee(),
                            $3d: ee()
                        }
                    },
                    init: function() {
                        var t = this;
                        $.on("mouseenter." + B, function() {
                            (t.wrappers.cursor.$2d.length || t.wrappers.cursor.$3d.length) && t.calculateTransformProperties()
                        }), $.on("mousemove." + B, function(e) {
                            (t.wrappers.cursor.$2d.length || t.wrappers.cursor.$3d.length) && t.mouseMove(e)
                        }), $.on("mouseleave." + B, function() {
                            (t.wrappers.cursor.$2d.length || t.wrappers.cursor.$3d.length) && t.reset()
                        }), Z.device.isMobile && Z.device.supportOrientation && (ee(window).on("deviceorientation." + B, function() {
                            t.state.ready && t.deviceTurn(event)
                        }), ee(window).on("orientationchange." + B, function() {
                            t.calculateTransformProperties()
                        })), ee(window).on("scroll.parallax" + B + " touchmove.parallax" + B, function() {
                            (t.wrappers.scroll.$2d.length || t.wrappers.scroll.$3d.length) && t.scroll()
                        }), t.defaults.scrollModifier *= Z.o.parallaxScrollReverse ? -1 : 1
                    },
                    addLayer: function(e, t, i, a) {
                        switch (this.state.enabled || (Z.functions.setStates(this, {
                            enabled: !0
                        }), this.init()), ee.extend(!0, t, this.defaultProperties, Z.slides[a].parallax, i.parallax), i.transformPerspective.parallax ? t.transformPerspective = i.transformPerspective.parallax : i.transformPerspective.parallax = t.transformPerspective, t.event.match(/(cursor|scroll|auto)/) || (t.event = "cursor"), t.path.match(/(circle|oval-h|oval-v|infinity|linear-h|linear-v)/) || (t.path = "circle"), t.direction.match(/(clockwise|counterclockwise)/) || (t.direction = "clockwise"), t.type.match(/(2d,3d)/) && (t.type = "2d"), (i.parallax = t).axis) {
                            case "none":
                                t.x = !1, t.y = !1;
                                break;
                            case "x":
                                t.y = !1;
                                break;
                            case "y":
                                t.x = !1
                        }
                        this.wrappers[t.event]["$" + t.type] = this.wrappers[t.event]["$" + t.type].add(e)
                    },
                    addShadow: function() {
                        var e, t, i, a = Z.gui.shadow.$element,
                            s = (Z.slides.current && Z.slides.current.parallax ? Z.slides.current : Z.slides.next).index;
                        Z.slides[s].data.$background && Z.slides[s].data.$background.data(Z.defaults.init.dataKey).parallax.enabled && Z.slides[s].data.overflow && "hidden" !== Z.slides[s].data.overflow && (e = "50% -" + .25 * Z.slider.height + "px 0", i = void 0 !== (t = Z.slides[s].data.$background.data(Z.defaults.init.dataKey).parallax).rotation ? 2 * t.rotation : void 0 !== Z.slides[s].parallax.rotation ? 2 * Z.slides[s].parallax.rotation : 2 * this.defaultProperties.rotation, a.data(Z.defaults.init.dataKey, {
                            parallax: ee.extend(!0, {}, this.defaultProperties, Z.slides[s].parallax, {
                                level: t.level,
                                transformOrigin: e,
                                rotation: i
                            })
                        }), a.attr("data-ls-parallax", "active"), J.TweenMax.set(a[0], {
                            transformOrigin: e,
                            transformPerspective: a.data(Z.defaults.init.dataKey).parallax.transformPerspective * Z.resize.ratio
                        }), "3d" === Z.slides[s].parallax.type || "3d" === t.type ? this.wrappers.cursor.$3d = this.wrappers.cursor.$3d.add(a) : this.wrappers.cursor.$2d = this.wrappers.cursor.$2d.add(a)), this.shadowIsChecked = !0
                    },
                    removeShadow: function() {
                        var e = Z.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() {
                        ee().add(this.wrappers.cursor.$2d).add(this.wrappers.cursor.$3d).add(this.wrappers.scroll.$2d).add(this.wrappers.scroll.$3d).add(this.wrappers.auto.$2d).add(this.wrappers.auto.$3d).each(function() {
                            var e = ee(this),
                                t = e.data(Z.defaults.init.dataKey).parallax,
                                i = e.find(".ls-layer"),
                                a = i.data(Z.defaults.init.dataKey);
                            J.TweenMax.set(ee(this)[0], {
                                transformOrigin: Z.functions.convert.transformOrigin(t.transformOrigin, i.data(Z.defaults.init.dataKey).elements.$wrapper, a, e),
                                transformPerspective: t.transformPerspective * a.settings.calculatedratio
                            })
                        }), this.transformPropertiesCalculated = !0
                    },
                    deviceTurn: function(e) {
                        var t, i;
                        this.transformPropertiesCalculated ? (e = 0 === (t = window.orientation) ? (i = 5 * -parseInt(e.gamma) * this.defaults.sensitive * Z.resize.ratio, 5 * (this.defaults.centerDegree - parseInt(e.beta)) * this.defaults.sensitive * Z.resize.ratio) : 90 === t ? (i = 5 * -parseInt(e.beta) * this.defaults.sensitive * Z.resize.ratio, 5 * (parseInt(e.gamma) + this.defaults.centerDegree) * this.defaults.sensitive * Z.resize.ratio) : (i = 5 * parseInt(e.beta) * this.defaults.sensitive * Z.resize.ratio, 5 * (this.defaults.centerDegree - parseInt(e.gamma)) * this.defaults.sensitive * Z.resize.ratio), this.animate2D(i, e, "cursor"), this.animate3D(i, e, "cursor")) : this.calculateTransformProperties(), Z.slider.state.animatingSlides || this.shadowIsChecked || !Z.gui.shadow.$element || this.addShadow()
                    },
                    trigger: function() {
                        ee(window).trigger("scroll.parallax" + B), ee(window).trigger("touchmove.parallax" + B)
                    },
                    auto: function() {
                        this.transformPropertiesCalculated || this.calculateTransformProperties()
                    },
                    scroll: function() {
                        var e = (("top" === this.defaults.centerLayers ? Z.device.winScrollTop : Z.device.winScrollTop + (Z.device.viewportHeight - Z.slider.height) / 2) - Z.slider.offsetTop) * Z.resize.ratio * this.defaults.scrollModifier;
                        Z.slider.state.inFullscreen && (e = 0), this.transformPropertiesCalculated || this.calculateTransformProperties(), this.animate2D(0, e, "scroll"), this.animate3D(0, e, "scroll")
                    },
                    mouseMove: function(e) {
                        var t, i;
                        this.transformPropertiesCalculated ? (Z.slider.state.animatingSlides || this.shadowIsChecked || !Z.gui.shadow.$element || this.addShadow(), t = Z.slider.offsetLeft + Z.slider.width / 2, i = Z.slider.offsetTop + Z.slider.height / 2, t = e.pageX - t, i = e.pageY - i, this.animate2D(t, i, "cursor"), this.animate3D(t, i, "cursor")) : this.calculateTransformProperties()
                    },
                    animate2D: function(s, r, e) {
                        this.wrappers[e].$2d.each(function() {
                            var e, t, i, a = ee(this);
                            "active" === a.attr("data-ls-parallax") && (t = (e = a.data(Z.defaults.init.dataKey).parallax).x ? -s * (e.distance / 2e3) * parseInt(e.level) : 0, i = e.y ? -r * (e.distance / 2e3) * parseInt(e.level) : 0, J.TweenMax.to(a[0], e.durationMove, {
                                x: t,
                                y: i
                            }))
                        })
                    },
                    animate3D: function(o, n, e) {
                        this.wrappers[e].$3d.each(function() {
                            var e, t, i, a, s, r = ee(this);
                            "active" === r.attr("data-ls-parallax") && (a = (e = r.data(Z.defaults.init.dataKey).parallax).x ? (i = -o / (4e3 / e.rotation), -o * (e.distance / 2e3) * parseInt(e.level)) : i = 0, s = e.y ? (t = n / (4e3 / e.rotation), -n * (e.distance / 2e3) * parseInt(e.level)) : t = 0, J.TweenMax.to(r[0], e.durationMove, {
                                rotationX: t,
                                rotationY: i,
                                x: a,
                                y: s
                            }))
                        })
                    },
                    reset: function() {
                        ee().add(this.wrappers.cursor.$2d).add(this.wrappers.cursor.$3d).each(function() {
                            var e = ee(this);
                            "active" === e.attr("data-ls-parallax") ? J.TweenMax.to(e[0], ee(this).data(Z.defaults.init.dataKey).parallax.durationLeave, {
                                x: 0,
                                y: 0,
                                rotationX: 0,
                                rotationY: 0
                            }) : J.TweenMax.set(e[0], {
                                x: 0,
                                y: 0,
                                rotationX: 0,
                                rotationY: 0
                            })
                        }), Z.gui.shadow.$element && this.removeShadow(), this.transformPropertiesCalculated = !1
                    }
                }, scroll: {
                    defaultProperties: {
                        shouldBeConverted: {
                            transformOrigin: "50% 50% 0"
                        },
                        transformPerspective: 500,
                        duration: .5
                    },
                    defaults: {
                        centerLayers: "center"
                    },
                    state: {
                        enabled: !1
                    },
                    $wrappers: ee(),
                    init: function() {
                        var e = this;
                        ee(window).on("scroll.scroll" + B + " touchmove.scroll" + B, function() {
                            e.$wrappers.length && e.scroll()
                        }), ee(window).on("resize.scroll" + B, function() {
                            e.$wrappers.length && e.calculateTransformProperties()
                        })
                    },
                    addLayer: function(e, t, i, a) {
                        this.state.enabled || (Z.functions.setStates(this, {
                            enabled: !0
                        }), this.init()), ee.extend(!0, t, this.defaultProperties, i.scroll), i.transformPerspective.scroll ? t.transformPerspective = i.transformPerspective.scroll : i.transformPerspective.scroll = t.transformPerspective, i.scroll = t, this.$wrappers = this.$wrappers.add(e)
                    },
                    getCenter: function(e) {
                        switch (e) {
                            case "top":
                                e = Z.device.winScrollTop;
                                break;
                            case "center":
                                e = Z.device.winScrollTop + (Z.device.viewportHeight - Z.slider.height) / 2;
                                break;
                            case "bottom":
                                e = Z.device.winScrollTop + Z.device.viewportHeight - Z.slider.height
                        }
                        return e
                    },
                    scroll: function(r) {
                        var o, n = this,
                            l = this.getCenter(this.defaults.centerLayers);
                        this._timeline && this._timeline.pause().clear().kill(), this._timeline = new J.TimelineMax({
                            paused: !0
                        }), this.transformPropertiesCalculated || this.calculateTransformProperties(), this.$wrappers.each(function() {
                            var e = ee(this),
                                t = e.find(".ls-scroll-transform"),
                                i = e.data(Z.defaults.init.dataKey).scroll;
                            o = i.center && l !== i.center ? n.getCenter(i.center) : l, s = Z.slider.state.inFullscreen ? 0 : o - Z.slider.offsetTop;
                            var a = {
                                    x: i.x ? n.calculateTransformations(-s * i.x / 20, "x", i, -s) : 0,
                                    y: i.y ? n.calculateTransformations(-s * i.y / 20, "y", i, -s) : 0
                                },
                                s = {
                                    rotation: i.rotation ? n.calculateTransformations(s * i.rotation / 40, "rotation", i, -s) : 0,
                                    rotationX: i.rotationX ? n.calculateTransformations(s * i.rotationX / 40, "rotationX", i, -s) : 0,
                                    rotationY: i.rotationY ? n.calculateTransformations(s * i.rotationY / 40, "rotationY", i, -s) : 0,
                                    skewX: i.skewX ? n.calculateTransformations(-s * i.skewX / 40, "skewX", i, -s) : 0,
                                    skewY: i.skewY ? n.calculateTransformations(-s * i.skewY / 40, "skewY", i, -s) : 0,
                                    scaleX: i.scaleX ? n.calculateTransformations(1 - s * i.scaleX / -4e3, "scaleX", i, s) : 1,
                                    scaleY: i.scaleY ? n.calculateTransformations(1 - s * i.scaleY / -4e3, "scaleY", i, s) : 1,
                                    opacity: i.opacity ? n.calculateTransformations(1 - s * (i.opacityyoyo ? Math.abs(i.opacity) : i.opacity) / 1e3, "opacity", i, s) : 1
                                };
                            r || 0 == i.duration ? (n._timeline.set(e[0], a), n._timeline.set(t[0], s)) : (n._timeline.to(e[0], i.duration, a, 0), n._timeline.to(t[0], i.duration, s, 0))
                        }), this._timeline.play()
                    },
                    calculateTransformations: function(e, t, i, a) {
                        if (i[t + "yoyo"]) switch (t) {
                            case "scaleX":
                            case "scaleY":
                                a < 0 && (e = 1 - (e - 1));
                                break;
                            case "opacity":
                                a < 1 && (e = 1 - (e - 1));
                                break;
                            default:
                                a < 1 && (e = -e)
                        }
                        return "opacity" == t && i.opacityinvert && (e = 1 - e), void 0 !== i[t + "min"] && e < i[t + "min"] && (e = i[t + "min"]), void 0 !== i[t + "max"] && e > i[t + "max"] && (e = i[t + "max"]), ("x" === t && i.xresponsive || "y" === t && i.yresponsive) && (e *= Z.resize.ratio), e
                    },
                    calculateTransformProperties: function() {
                        this.$wrappers.each(function() {
                            var e = ee(this).data(Z.defaults.init.dataKey).scroll,
                                t = ee(this).find(".ls-layer"),
                                i = t.data(Z.defaults.init.dataKey);
                            J.TweenMax.set(ee(this).find(".ls-scroll-transform")[0], {
                                transformOrigin: Z.functions.convert.transformOrigin(e.shouldBeConverted.transformOrigin, ee(this), i, t),
                                transformPerspective: e.transformPerspective * i.settings.calculatedratio
                            })
                        }), this.transformPropertiesCalculated = !0
                    },
                    trigger: function() {
                        this.scroll(!0)
                    },
                    reset: function() {
                        this.transformPropertiesCalculated = !1
                    }
                }, filters: {
                    createTransition: function(e, t, i, a) {
                        var s, r = new Z.defaults.layer.properties.filter,
                            o = {};
                        for (s in r) switch (t) {
                            case "in":
                                o[s] = [r[s], r[s]], o[s][0] = (i.hasOwnProperty(s) ? i : a.hasOwnProperty(s) ? a : r)[s], o[s][1] = (a.hasOwnProperty(s) ? a : r)[s], e.filter.values.afterIn[s] = o[s][1];
                                break;
                            case "hover":
                            case "loop":
                            case "out":
                                o[s] = [], o[s][0] = (i.hasOwnProperty(s) ? i : r)[s], o[s][1] = (a.hasOwnProperty(s) ? a : i.hasOwnProperty(s) && i[s] !== r[s] ? i : r)[s], "loop" === t && !0 !== e.loop.yoyo && -1 !== e.loop.count && (e.filter.values.afterLoop[s] = o[s][1]);
                                break;
                            case "bg":
                                o[s] = [r[s], r[s]], i.hasOwnProperty(s) && (o[s][0] = i[s]), a.hasOwnProperty(s) && (o[s][1] = a[s])
                        }
                        return o
                    },
                    convert: function(e) {
                        for (var t, i, a = {}, s = /(blur|brightness|contrast|grayscale|hue-rotate|invert|saturate|sepia)/i, r = 0, o = (e = e.split(" ")).length; r < o; r++)(t = (i = e[r].split("("))[0]).match(s) && (i = parseInt(i[1]), a[t] = i);
                        return a
                    },
                    animate: function(e, t) {
                        var i = 100 * e.target[0].p;
                        if ("object" == typeof t) {
                            var a, s = "";
                            for (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) + "% )"
                                }
                                J.TweenMax.set(e.target, {
                                "-webkit-filter": s,
                                filter: s
                            })
                        }
                    }
                }, splitType: {
                    setNodesSequence: function(e, o) {
                        function t(e, t) {
                            if ("desc" == t) e = o.slice(0).reverse();
                            else if ("rand" == t) e = o.slice(0).sort(function() {
                                return .5 - Math.random()
                            });
                            else if ("center" == t) {
                                var i, a = Math.floor(o.length / 2);
                                for (e = [o[a]], i = 1; i <= a; i++) e.push(o[a - i], o[a + i]);
                                e.length = o.length
                            } else if ("edge" == t) {
                                var s, r = Math.floor(o.length / 2);
                                for (e = [o[0]], s = 1; s <= r; s++) e.push(o[o.length - s], o[s]);
                                e.length = o.length
                            }
                            return e || o
                        }
                        var i = t(o, e[1]),
                            e = {
                                asc: "desc",
                                desc: "asc"
                            }[e[1]] || e[1];
                        return [i, t(o, e)]
                    },
                    resetNodes: function(e, t) {
                        ee(".char, .word, .line", e).add(t.elements.$wrapper).css({
                            transform: "none",
                            opacity: 1
                        }).each(function() {
                            delete this._gsTransform
                        })
                    },
                    setRandomProperties: function(e, t, i, a) {
                        for (var s in t) {
                            for (var r = [], o = 0, n = e["text" + a].nodes.length; o < n; o++) r[o] = Z.functions.convert.randomProperties(t[s], s);
                            delete i[s], i.cycle[s] = r
                        }
                        t = null
                    }
                }
            },
            media: {
                defaults: {
                    delay: 500,
                    fadeIn: 500,
                    fadeOut: 750
                },
                changeBackgroundVideo: function(e, t) {
                    var i, a, s, r;
                    Z.slides.current.index && Z.slides.current.data.$backgroundVideo.length && (r = (i = Z.slides.current.data.$backgroundVideo).data(Z.defaults.init.dataKey).elements.$bgWrapper, t && (i.data(Z.defaults.init.dataKey).mediaProperties.willBePaused = !0, r.fadeOut(Z.transitions.media.defaults.fadeOut, function() {
                        i.trigger("stopBackgroundVideo"), i.data(Z.defaults.init.dataKey).mediaProperties.willBePaused = !1
                    }))), Z.slides.next.data.$backgroundVideo.length && (s = (a = Z.slides.next.data.$backgroundVideo).data(Z.defaults.init.dataKey).elements.$bgWrapper, r = a.data(Z.defaults.init.dataKey).elements.$bgOuterWrapper, Z.device.isMobile && ($.hasClass("ls-device-is-phone") && r.hasClass("ls-hide-on-phone") || $.hasClass("ls-device-is-tablet") && r.hasClass("ls-hide-on-tablet")) || setTimeout(function() {
                        a.trigger("playBackgroundVideo")
                    }, e ? 50 : 0), e || t ? s.fadeIn(Z.transitions.media.defaults.fadeOut) : s.css({
                        display: "block"
                    }), a.data(Z.defaults.init.dataKey).mediaProperties.isPreloaded = !0)
                }
            },
            timers: {
                defaults: {
                    fadeInDuration: .35,
                    reverseDuration: .3
                },
                create: function(e) {
                    this.curNext = e || "next", this.reset(), Z.gui.timers.bar.$element && this.bar.createTransition(), Z.gui.timers.circle.$element && this.circle.createTransition(), Z.gui.timers.slidebar.$element && this.slidebar.createTransition()
                },
                reverse: function() {
                    var e;
                    Z.slides.current && Z.slides.current.data && Z.transitions._slideTimeline && (e = Z.transitions._slideTimeline.progress(), e = Z.slides.current.data.duration * e / this.defaults.reverseDuration, Z.gui.timers.bar.$element && this.bar._transition && (Z.transitions._slideTimeline.remove(Z.transitions.timers.bar._transition), this.bar._transition.reverse().timeScale(e)), Z.gui.timers.circle.$element && this.circle._transition && (Z.transitions._slideTimeline.remove(Z.transitions.timers.circle._transition), this.circle._transition.reverse().timeScale(e)), Z.gui.timers.slidebar.$element && this.slidebar._transition && (Z.transitions._slideTimeline.remove(Z.transitions.timers.slidebar._transition), this.slidebar._transition.reverse().timeScale(e)))
                },
                reset: function() {
                    Z.gui.timers.bar.$element && this.bar._transition && this.bar.reset(), Z.gui.timers.circle.$element && this.circle._transition && this.circle.reset(), Z.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 = J.TweenMax.fromTo(Z.gui.timers.bar.$element[0], Z.slides[Z.transitions.curNext].data.duration, {
                            autoCSS: !1,
                            paused: !0,
                            css: {
                                width: 0
                            }
                        }, {
                            autoCSS: !1,
                            css: {},
                            ease: J.Linear.easeNone,
                            onReverseComplete: function() {
                                Z.transitions.timers.bar._transition = !1
                            },
                            onComplete: function(e) {
                                e.target.style.width = "100%", e.target.style.width = "calc( 100% - " + Z.slider.initial.skinWidth + "px )"
                            },
                            onCompleteParams: ["{self}"],
                            onUpdate: function(e) {
                                e.target.style.width = Math.min(Z.slider.width, Z.slider.width * e.progress()) + "px"
                            },
                            onUpdateParams: ["{self}"]
                        })
                    }
                },
                circle: {
                    reset: function() {
                        this._transition && (Z.gui.timers.circle.$element.stop(!0, !0), this._transition.kill(), this._transition = !1)
                    },
                    createTransition: function() {
                        var e = Z.gui.timers.circle.$element.find(".ls-ct-right .ls-ct-rotate")[0],
                            t = Z.gui.timers.circle.$element.find(".ls-ct-left .ls-ct-rotate")[0],
                            i = Z.slides[Z.transitions.curNext].data.duration;
                        this._transition = new J.TimelineMax({
                            paused: !0
                        }).fromTo(Z.gui.timers.circle.$element[0], Z.transitions.timers.defaults.fadeInDuration, {
                            autoCSS: !1,
                            immediateRender: !0,
                            css: {
                                opacity: 0,
                                display: "block"
                            }
                        }, {
                            autoCSS: !1,
                            css: {
                                opacity: Z.gui.timers.circle.$element.data("original").opacity
                            }
                        }).fromTo(e, i / 2, {
                            autoCSS: !1,
                            css: {
                                rotation: 0
                            }
                        }, {
                            autoCSS: !1,
                            css: {
                                rotation: 180
                            },
                            ease: J.Linear.easeNone
                        }, 0).fromTo(t, i / 2, {
                            autoCSS: !1,
                            css: {
                                rotation: 0
                            }
                        }, {
                            autoCSS: !1,
                            css: {
                                rotation: 180
                            },
                            ease: J.Linear.easeNone
                        }, i / 2)
                    }
                },
                slidebar: {
                    reset: function() {
                        this._transition && (this._transition.kill(), this._transition = !1)
                    },
                    createTransition: function() {
                        var i = this;
                        i._transition = new J.TimelineMax({
                            paused: !0,
                            onReverseComplete: function() {
                                Z.transitions.timers.slidebar._transition = !1
                            }
                        }), ee.each(Z.gui.timers.slidebar.$sliderContainerElement, function(t, e) {
                            i._transition.add(J.TweenMax.fromTo(Z.gui.timers.slidebar.$sliderContainerElement[t][0], Z.slides[Z.transitions.curNext].data.duration, {
                                autoCSS: !1,
                                css: {
                                    left: 0
                                }
                            }, {
                                autoCSS: !1,
                                css: {},
                                ease: J.Linear.easeNone,
                                onComplete: function(e) {
                                    e.target.style.left = "calc( 100% - " + Z.gui.timers.slidebar.sliderContainerElementWidth[t] + "px )"
                                },
                                onCompleteParams: ["{self}"],
                                onUpdate: function(e) {
                                    e.target.style.left = (Z.gui.timers.slidebar.containerElementWidth[t] - Z.gui.timers.slidebar.sliderContainerElementWidth[t]) * e.progress() + "px"
                                },
                                onUpdateParams: ["{self}"]
                            }), 0), i._transition.add(J.TweenMax.fromTo(Z.gui.timers.slidebar.$progressBarElement[t][0], Z.slides[Z.transitions.curNext].data.duration, {
                                autoCSS: !1,
                                css: {
                                    width: 0
                                }
                            }, {
                                autoCSS: !1,
                                css: {},
                                ease: J.Linear.easeNone,
                                onComplete: function(e) {
                                    e.target.style.width = "100%"
                                },
                                onCompleteParams: ["{self}"],
                                onUpdate: function(e) {
                                    e.target.style.width = Z.gui.timers.slidebar.elementWidth[t] * e.progress() + "px"
                                },
                                onUpdateParams: ["{self}"]
                            }), 0)
                        })
                    }
                }
            }
        }, Z.plugins = {
            load: function() {
                var e, a;
                Z.o.plugins && 0 !== Z.o.plugins.length ? (e = Z.o.plugins[0], a = "object" == typeof e ? e.namespace : e, window._layerSlider.plugins[a] ? (Z.plugins.init(a, e, !0), Z.plugins.load()) : Z.browser.usesFileProtocol || "object" != typeof e ? (Z.browser.usesFileProtocol ? window.console && (console.error(Z.defaults.slider.errorText, "Cannot load plugins on file:// protocol."), console.info("Please include the plugin files manually.")) : window.console && (console.error(Z.defaults.slider.errorText, "Plugin files are missing!"), console.info('Plugin "' + a + '" has been added in slider init options, but the source files are not found on page.')), Z.o.plugins.splice(0, 1), Z.plugins.load()) : -1 === window._layerSlider.pluginsBeingLoaded.indexOf(a) ? -1 === window._layerSlider.pluginsLoaded.indexOf(a) && -1 === window._layerSlider.pluginsNotLoaded.indexOf(a) ? (window._layerSlider.pluginsBeingLoaded.push(a), ee.ajax({
                    url: -1 === e.js.indexOf("http://") && -1 === e.js.indexOf("https://") ? (window._layerSlider.pluginsPath || window._layerSlider.scriptPath + "/../plugins/") + e.js : e.js,
                    dataType: "script",
                    success: function() {
                        Z.plugins.init(e.namespace, e, !0), window._layerSlider.pluginsLoaded.push(a)
                    },
                    error: function(e, t, i) {
                        window.console && (console.error(Z.defaults.slider.errorText, a, "plugin has not been loaded!"), console.error("Additional error info:", i)), window._layerSlider.pluginsNotLoaded.push(a)
                    },
                    complete: function() {
                        window._layerSlider.pluginsBeingLoaded.splice(window._layerSlider.pluginsBeingLoaded.indexOf(a), 1), Z.plugins.load()
                    }
                })) : (Z[a] || -1 !== window._layerSlider.pluginsNotLoaded.indexOf(a) ? Z.o.plugins.splice(0, 1) : Z.plugins.init(a, e), Z.plugins.load()) : Z.plugins.checkLoaded(a)) : Z.slider.check.initialized()
            },
            init: function(e, t, i) {
                Z.initializedPlugins[e] = new window._layerSlider.plugins[e](Z, $, B, t.settings), window._layerSlider.checkVersions(Z.initializedPlugins[e].pluginData.requiredLSVersion, Z.plugin.version) ? (t.css && i && ee('<link rel="stylesheet" href="' + (-1 === t.css.indexOf("http://") && -1 === t.css.indexOf("https://") ? (window._layerSlider.pluginsPath || window._layerSlider.scriptPath + "/../plugins/") + t.css : t.css) + '">').appendTo("head"), Z.initializedPlugins[e].init && Z.initializedPlugins[e].init()) : window.console && console.error(Z.defaults.slider.errorText, e, "plugin has not been loaded! Required LayerSlider version:", Z.initializedPlugins[e].pluginData.requiredLSVersion, "(you have:", Z.plugin.version + ")"), Z.o.plugins.splice(0, 1)
            },
            checkLoaded: function(e) {
                Z.intervals.pluginLoaded = setInterval(function() {
                    -1 === window._layerSlider.pluginsLoaded.indexOf(e) && -1 === window._layerSlider.pluginsNotLoaded.indexOf(e) || -1 !== window._layerSlider.pluginsBeingLoaded.indexOf(e) || (clearInterval(Z.intervals.pluginLoaded), delete Z.intervals.pluginLoaded, Z.plugins.load())
                }, 100)
            }
        }, Z.slider = {
            shouldResize: !0,
            thumbnails: [],
            state: {
                isHidden: !1,
                isPaused: !1,
                preloadingImages: !1,
                changingSlides: !1,
                animatingSlides: !1
            },
            isBusy: function() {
                return this.state.preloadingImages || this.state.changingSlides || this.state.animatingSlides
            },
            checkVisibility: function() {
                !!Z.slider.$innerWrapper.width() ? (this.state.isHidden && Z.resize.all(), this.state.isHidden = !1) : this.state.isHidden = !0
            },
            load: function() {
                if (!document.body.contains(I)) return !1;
                Z.api.hasEvent("sliderWillLoad") && Z.api.triggerEvent("sliderWillLoad"), Z.slider.set.global()
            },
            set: {
                global: function() {
                    var e;
                    Z.originalMarkup = $[0].outerHTML, Z.userInitOptions = Z.functions.convert.properties(Z.functions.convert.oldProperties(i)), Z.meta = {}, Z.o = ee.extend(!0, {}, Z.defaults.init.options, Z.userInitOptions), Z.o.forceLayersOutDuration /= 1e3, Z.o.forceLayersOutDuration = 0 < Z.o.forceLayersOutDuration ? Z.o.forceLayersOutDuration : .75, Z.o.sliderFadeInDuration /= 1e3, window.console && !0 !== Z.o.hideWelcomeMessage && !0 !== window._layerSlider.hideWelcomeMessage && (window._layerSlider.hideWelcomeMessage = !0, t = window.console.info ? "info" : "log", e = window.LS_Meta && window.LS_Meta.v ? " | WP Plugin: " + window.LS_Meta.v : "", console[t]("LayerSlider initialized | core: " + Z.plugin.version + "-" + Z.plugin.release + e), console[t]("Find updates and docs @ https://layerslider.com/"));
                    var t = {
                        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], t.js = window._layerSlider.pluginsPath + "debug/layerslider.debug.js", t.css = window._layerSlider.pluginsPath + "debug/layerslider.debug.css"), "object" == typeof Z.o.plugins ? Z.o.plugins.push(t) : Z.o.plugins = [t]), (window._layerSlider.currentScript || window._layerSlider.lsScript) && (window._layerSlider.scriptPath = (window._layerSlider.currentScript || window._layerSlider.lsScript).src.replace(/\\/g, "/").replace(/\/[^\/]*$/, "")), "object" == typeof Z.o.plugins ? Z.plugins.load() : Z.slider.check.initialized()
                },
                styles: function() {
                    var e, t, i, a, s, r, o, n, l, d, c, u, p, h, m, f, g, y, v = Z.slider,
                        b = $.parent(),
                        w = I.style,
                        S = window.getComputedStyle(I, null),
                        x = parseInt(I.clientWidth),
                        T = parseInt(I.clientHeight),
                        C = parseInt(b.width()),
                        k = parseInt(b.height()),
                        O = Z.o.layersContainerWidth,
                        P = Z.o.layersContainerHeight,
                        L = Z.o.type.toLowerCase();
                    switch (Z.debugMode && Z.debug.add("group", "sliderInit.style"), Z.o.width ? e = -1 == Z.o.width.indexOf("%") ? parseInt(Z.o.width) : Z.o.width : w.width ? e = -1 == w.width.indexOf("%") ? parseInt(w.width) : w.width : 0 < O ? (e = O, Z.debugMode && Z.debug.add("warn", "sliderInit.noWidth", O)) : (e = x, Z.debugMode && Z.debug.add("warn", "sliderInit.noWidth2", x)), i = e, Z.o.height ? t = -1 == Z.o.height.indexOf("%") ? parseInt(Z.o.height) : Z.o.height : w.height ? t = -1 == w.height.indexOf("%") ? parseInt(w.height) : w.height : 0 < P ? (t = P, Z.debugMode && Z.debug.add("warn", "sliderInit.noHeight", P)) : (t = T, Z.debugMode && Z.debug.add("warn", "sliderInit.noHeight2", k)), a = t, s = "" !== w.maxWidth ? -1 === w.maxWidth.indexOf("%") ? parseInt(w.maxWidth) : w.maxWidth : 0, void 0 === Z.userInitOptions.type && (0 < O && 0 < P || "100%" === e && "100%" === t ? L = "fullsize" : O <= 0 && P <= 0 && (Z.o.responsiveUnder <= 0 || 0 < Z.o.responsiveUnder && Z.o.sliderVersion) ? L = void 0 !== Z.o.responsive && !1 === Z.o.responsive ? "fixedsize" : "responsive" : 0 < Z.o.responsiveUnder && (L = "fullwidth")), L) {
                        case "fullwidth":
                            -1 !== e.indexOf("%") && (Z.debugMode && Z.debug.add("warn", "sliderInit.percWidth", [L, e, x]), e = x), O <= 0 && (O = e, Z.debugMode && Z.debug.add("warn", "sliderInit.conWidth", [L, e])), Z.o.responsiveUnder <= 0 && (Z.o.responsiveUnder = O, Z.debugMode && Z.debug.add("warn", "sliderInit.fullwidth", O)), -1 !== t.indexOf("%") && (o = k / (100 / parseInt(t)), Z.debugMode && Z.debug.add("warn", "sliderInit.fullwidth2", [L, t, o]), t = o), P <= 0 && (P = t);
                            break;
                        case "fullsize":
                            -1 !== e.indexOf("%") && (r = 0 < O ? O : C, Z.debugMode && Z.debug.add("warn", "sliderInit.fullsize", [L, e, r, C, O]), e = r), O <= 0 && (O = e, Z.debugMode && Z.debug.add("warn", "sliderInit.conWidth", [L, e])), -1 !== t.indexOf("%") && (o = 0 < P ? P : ee(window).height() / (100 / parseInt(t)), Z.debugMode && Z.debug.add("warn", "sliderInit.fullsize2", [L, t, o, ee(window).height(), P]), t = o), P <= 0 && (P = t, Z.debugMode && Z.debug.add("warn", "sliderInit.conHeight", [L, t]));
                            break;
                        case "fixedsize":
                            break;
                        default:
                            Z.userInitOptions.type = Z.o.type = L = "responsive", (Z.o.responsiveUnder = -1) !== e.indexOf("%") && (e = x, Z.debugMode && Z.debug.add("warn", "sliderInit.percWidth", [L, e, x])), -1 !== t.indexOf("%") && (e = T, Z.debugMode && Z.debug.add("warn", "sliderInit.responsive", [L, t, T])), Z.debugMode && 0 < O && Z.debug.add("warn", "sliderInit.conWidth2", [L, O]), Z.debugMode && 0 < P && Z.debug.add("warn", "sliderInit.conHeight2", [L, P])
                    }
                    $.addClass("ls-container ls-" + L), $.parent().addClass("ls-direction-fix"), Z.o.preventSliderClip && Z.o.fitScreenWidth && ("fullwidth" === L || "fullsize" === L && "fitheight" !== Z.o.fullSizeMode) && $.parents(":not(body, html)").each(function() {
                        ee(this).addClass("ls-overflow-visible")
                    }), Z.userInitOptions.slideBGSize || "responsive" !== L || !Z.userInitOptions.hasOwnProperty("sliderVersion") || Z.userInitOptions.sliderVersion || (Z.o.slideBGSize = "auto", Z.debugMode && Z.debug.add("warn", "sliderInit.bgCover", L)), Z.o.slideBGSize = Z.o.slideBGSize.replace("100% 100%", "stretch"), n = 0 < O ? O : e, l = 0 < P ? P : t, (d = "auto" === (y = I.style.marginLeft) ? "auto" : "" === y ? parseInt(S.getPropertyValue("margin-left")) : parseInt(I.style.marginLeft)) === (c = "auto" === (g = I.style.marginRight) ? "auto" : "" === g ? parseInt(S.getPropertyValue("margin-right")) : parseInt(I.style.marginRight)) && ("" === y && "" === g && (u = d, c = d = "auto"), $.css({
                        marginLeft: "auto",
                        marginRight: "auto"
                    })), p = "" !== w.paddingLeft ? parseInt(w.paddingLeft) : parseInt($.css("padding-left")), m = "" !== w.paddingRight ? parseInt(w.paddingRight) : parseInt($.css("padding-right")), h = "" !== w.paddingTop ? parseInt(w.paddingTop) : parseInt($.css("padding-top")), f = "" !== w.paddingBottom ? parseInt(w.paddingBottom) : parseInt($.css("padding-bottom")), b = "" !== w.borderLeftWidth ? parseInt(w.borderLeftWidth) : parseInt($.css("border-left-width")), y = "" !== w.borderRightWidth ? parseInt(w.borderRightWidth) : parseInt($.css("border-right-width")), g = "" !== w.borderTopWidth ? parseInt(w.borderTopWidth) : parseInt($.css("border-top-width")), w = "" !== w.borderBottomWidth ? parseInt(w.borderBottomWidth) : parseInt($.css("border-bottom-width")), v.initial = {
                        type: L,
                        width: e,
                        height: t,
                        originalWidth: i,
                        originalHeight: a,
                        percW: e / 100,
                        percH: t / 100,
                        layersWidth: O,
                        layersHeight: P,
                        ratio: n / l,
                        maxWidth: s,
                        marginLeft: d,
                        marginRight: c,
                        marginTop: Z.o.marginTop,
                        marginBottom: Z.o.marginBottom,
                        paddingLeft: p,
                        paddingTop: h,
                        paddingRight: m,
                        paddingBottom: f,
                        borderLeftWidth: b,
                        borderTopWidth: g,
                        borderRightWidth: y,
                        borderBottomWidth: w,
                        skinWidth: p + m + b + y,
                        skinHeight: h + f + g + w
                    }, Z.debugMode && (Z.debug.add("log", "sliderInit.style", [e, t, i, a, O, P, parseInt(n / l * 100) / 100, 0 < s ? s : void 0, [d, c]]), u && Z.debug.add("warn", "sliderInit.margin", u)), ee("html").attr("id") ? ee("body").attr("id") || ee("body").attr("id", "ls-global") : ee("html").attr("id", "ls-global"), "static" !== S.getPropertyValue("position") && "absolute" !== S.getPropertyValue("position") && (I.style.position = "relative"), Z.o.insertSelector && $[Z.o.insertMethod](Z.o.insertSelector), Z.slider.$hiddenWrapper = ee('<div class="ls-wp-container fitvidsignore ls-hidden" data-layerslider-uid="' + B + '"></div>').addClass($.attr("class")).prependTo("body"), Z.slider.$innerWrapper = ee('<div class="ls-inner"></div>'), Z.slider.$slideBGColorWrapper = ee('<div class="ls-slide-bgcolor"></div>').appendTo(Z.slider.$innerWrapper), Z.slider.$layersWrapper = ee('<div class="ls-layers"></div>').appendTo(Z.slider.$innerWrapper), Z.slider.$bgVideosWrapper = ee('<div class="ls-background-videos"></div>').appendTo(Z.slider.$layersWrapper), Z.slider.$slideBGWrapper = ee('<div class="ls-slide-backgrounds"></div>').appendTo(Z.slider.$layersWrapper), Z.slider.$innerWrapper.appendTo($), !0 === Z.o.hideOnMobile && Z.device.isMobile ? ($.addClass("ls-forcehide"), $.closest(".ls-wp-fullwidth-container").addClass("ls-forcehide"), Z.o.autoStart = !1) : Z.slider.check.showHide();
                    S = !1; - 1 == Z.o.globalBGColor.indexOf("gradient") ? Z.slider.$innerWrapper.css({
                        backgroundColor: Z.o.globalBGColor
                    }) : (S = Z.o.globalBGColor, Z.o.globalBGColor = "transparent"), Z.o.globalBGImage ? Z.slider.$innerWrapper.css({
                        backgroundImage: "url( " + Z.o.globalBGImage + " )" + (S ? ", " + S : ""),
                        backgroundRepeat: Z.o.globalBGRepeat,
                        backgroundAttachment: Z.o.globalBGAttachment,
                        backgroundSize: Z.o.globalBGSize,
                        backgroundPosition: Z.o.globalBGPosition
                    }) : S && Z.slider.$innerWrapper.css({
                        backgroundImage: S
                    }), "transparent" != Z.o.globalBGColor || !1 !== Z.o.globalBGImage || S || Z.slider.$innerWrapper.css({
                        background: "none transparent"
                    }), Z.slider.$spacingWrapper = $
                },
                options: function() {
                    var t, i, a, s, r;
                    ee("html").find('meta[content*="WordPress"]').length && (Z.meta.wpVersion = ee("html").find('meta[content*="WordPress"]').attr("content").split("WordPress")[1]), window.LS_Meta && window.LS_Meta.v ? Z.meta.lswpVersion = window.LS_Meta.v : ee("html").find('script[src*="layerslider"]').length && -1 != ee("html").find('script[src*="layerslider"]').attr("src").indexOf("?") && (Z.meta.lswpVersion = ee("html").find('script[src*="layerslider"]').attr("src").split("?")[1].split("=")[1]), "undefined" != typeof layerSliderTransitions && (Z.t = ee.extend({}, layerSliderTransitions)), "undefined" != typeof layerSliderCustomTransitions && (Z.ct = ee.extend({}, layerSliderCustomTransitions)), Z.debugMode && ("undefined" != typeof layerCustomSliderTransitions ? (Z.debug.add("log", "sliderInit.customTransitions", !1), "undefined" == typeof layerSliderTransitions && Z.debug.add("warn", "sliderInit.slideTransitions")) : "undefined" == typeof layerSliderTransitions && Z.debug.add("warn", "sliderInit.noSlideTransitions")), "number" == typeof Z.o.parallaxCenterDegree && (Z.transitions.layers.parallax.defaults.centerDegree = Z.o.parallaxCenterDegree), "number" == typeof Z.o.parallaxSensitivity && (Z.transitions.layers.parallax.defaults.sensitive = Z.o.parallaxSensitivity), Z.o.parallaxCenterLayers && (Z.transitions.layers.parallax.defaults.centerLayers = Z.o.parallaxCenterLayers), Z.o.scrollCenterLayers && (Z.transitions.layers.scroll.defaults.centerLayers = Z.o.scrollCenterLayers), Z.o.playByScroll && (Z.o.cycles = -1, Z.o.startInViewport = !0, Z.o.pauseOnHover = !1, Z.o.autoStart = !1), Z.device.isMobile && (Z.o.pauseOnHover = !1), ee(window).on("hashchange." + B, function() {
                        document.location.hash && Z.slides.deeplink(document.location.hash)
                    }), Z.o.startInViewport && (Z.slider.positionToViewport = Z.device.winScrollTop > Z.slider.offsetTop - (Z.device.viewportHeight - Z.slider.height) / 2 ? "under" : "over", Z.o.playByScroll ? (t = !0, i = 4 * Z.o.playByScrollSpeed, Z.device.scroll.timeout = 250, Z.transitions.layers.timeline.timeScaleModifier = 0, ee(document).on("wheel." + B + " touchmove." + B, function(e) {
                        Z.device.isMobile ? (a = e.originalEvent.touches[0].clientY, s < a ? Z.device.scroll.direction = "up" : a < s && (Z.device.scroll.direction = "down"), r = s - a, s = a) : (0 < e.originalEvent.deltaY ? Z.device.scroll.direction = "down" : Z.device.scroll.direction = "up", r = e.originalEvent.deltaY), 0 !== Math.abs(r) && (Z.device.scroll.lastDirection ? Z.device.scroll.lastDirection !== Z.device.scroll.direction && (Z.device.scroll.lastDirection = Z.device.scroll.direction, Z.transitions.layers.timeline.timeScaleModifier = 0) : Z.device.scroll.lastDirection = Z.device.scroll.direction, "inside" === Z.slider.positionToViewport && (Z.resize.viewport(), 0 <= r ? Z.transitions.layers.timeline.scrollForward() : Z.transitions.layers.timeline.scrollBackwards(), t && (clearTimeout(Z.timeouts.scroll), t = !1, Z.transitions.layers.timeline.timeScaleModifier = Z.transitions.layers.timeline.timeScaleModifier < i ? Z.transitions.layers.timeline.timeScaleModifier + .25 : i, Z.timeouts.scroll2 = setTimeout(function() {
                            delete Z.timeouts.scroll2, t = !0, Z.device.scroll.timeout = 50 < Z.device.scroll.timeout ? Z.device.scroll.timeout - 50 : 50
                        }, Z.device.scroll.timeout))), Z.slider.check.positionToViewport())
                    })) : ee(window).on("scroll." + B, function() {
                        Z.slider.check.positionToViewport()
                    }), Z.timeouts.checkPosition = setTimeout(function() {
                        Z.slider.check.positionToViewport()
                    }, 25)), Z.slider.canShow = !0
                },
                attributes: function() {
                    $.attr("data-current-slide", Z.slides.current.index)
                }
            },
            check: {
                initialized: function() {
                    Z.debugMode && Z.debug.add("log", "sliderInit.info", [Z.plugin.version, Z.plugin.releaseDate, Z.userInitOptions.sliderVersion || "n/a or slider version is pre 6.0.0", $.attr("id"), B, ee.fn.jquery, Z.meta.lswpVersion, Z.meta.wpVersion], !0), Z.slider.initialized || (Z.slider.initialized = !0, this.skins())
                },
                skins: function() {
                    Z.o.skin && "" !== Z.o.skin && Z.o.skinsPath && "" !== Z.o.skinsPath ? Z.gui.skin.load() : Z.slider.init()
                },
                showHide: function() {
                    Z.device.isMobile && !1 !== Z.o.hideOnMobile || (Z.device.viewportWidth < Z.o.hideUnder || Z.device.viewportWidth > Z.o.hideOver && 0 < Z.o.hideOver ? Z.slider.hide() : Z.slider.show())
                },
                positionToViewport: function() {
                    var e, t;
                    delete Z.timeouts.checkPosition, Z.o.playByScroll && Z.device.scroll.direction && (t = "down" === Z.device.scroll.direction ? Z.device.winScrollTop : Z.slider.offsetTop - (Z.device.viewportHeight - Z.slider.height) / 2, (("down" === Z.device.scroll.direction ? Z.slider.offsetTop - (Z.device.viewportHeight - Z.slider.height) / 2 : Z.device.winScrollTop) < t && ("up" === Z.device.scroll.direction && "under" === Z.slider.positionToViewport || "down" === Z.device.scroll.direction && "over" === Z.slider.positionToViewport) || Z.device.docHeight <= Z.device.viewportHeight || Z.slider.height < Z.device.viewportHeight && ("up" === Z.device.scroll.direction && Z.device.winScrollTop <= 0 && Z.slider.offsetTop + Z.slider.height / 2 < Z.device.viewportHeight / 2 || "down" === Z.device.scroll.direction && Z.device.winScrollTop >= Z.device.docHeight - Z.device.viewportHeight && Z.slider.offsetTop + Z.slider.height / 2 > Z.device.winScrollTop + Z.device.viewportHeight / 2)) && (Z.slider.positionToViewport = "inside", Z.resize.viewport(), Z.device.scroll.disable())), Z.o.playByScroll || (e = Z.device.winScrollTop + Z.device.viewportHeight / 2, t = Z.slider.offsetTop + Z.slider.height / 2, (Math.abs(e - t) < Z.device.viewportHeight / 2 || Z.device.winScrollTop < Z.slider.offsetTop && Z.device.winScrollTop + Z.device.viewportHeight > Z.slider.offsetTop + Z.slider.height) && (Z.slider.positionToViewport = "inside", ee(window).off("scroll." + B), Z.debugMode && Z.debug.add("log", "slideshow.inviewport", !1), Z.transitions._slideTimeline && Z.transitions.layers.timeline.play()))
                }
            },
            init: function() {
                clearTimeout(Z.timeouts.skinLoad1), clearTimeout(Z.timeouts.skinLoad2), clearTimeout(Z.timeouts.skinLoad3), clearTimeout(Z.timeouts.skinLoad4), Z.device.setBasicEvents(), Z.slider.set.styles(), Z.slider.set.options(), Z.slides.init(), Z.device.fullscreen.set(), Z.media.init(), Z.gui.timers.init(), Z.gui.loadingIndicator.init(), Z.preload.init(), Z.gui.shadow.init(), Z.navigation.init(), Z.slideshow.init(), Z.slides.set.firstSlide(), Z.gui.navigation.init(), Z.gui.media.init(), Z.resize.slider(), Z.yourLogo.init(), ee(window).on("resize." + B, function() {
                    Z.slider.check.showHide(), "inside" === Z.slider.positionToViewport && Z.o.playByScroll && Z.resize.viewport(), Z.slider.shouldResize && Z.resize.all()
                }), Z.debugMode && (ee(window).off(".debug" + B), ee(window).on("resize.debug" + B, function() {
                    Z.debug.add("log", "resize.window", Z.device.viewportWidth, !0)
                })), ee(window).on("orientationchange." + B, function() {
                    Z.device.getDimensions(), Z.resize.all()
                }), Z.device.getDimensions(), ee(window).trigger("resize." + B), ee(window).trigger("orientationchange." + B), Z.o.refreshWaypoint && window.Waypoint && Waypoint.refreshAll(), Z.api.hasEvent("sliderDidLoad") && Z.api.triggerEvent("sliderDidLoad", Z.api.eventData()), Z.functions.setStates(Z.slider, {
                    isLoaded: !0
                }), Z.slider.state.shouldBeDestroyed ? Z.api.methods("destroy") : ((-1 < Z.o.hideOver || -1 < Z.o.hideUnder || "fullsize" == Z.slider.initial.type && "hero" == Z.o.fullSizeMode) && !Z.intervals.checkSliderOffset && (Z.intervals.checkSliderOffset = setInterval(function() {
                    Z.device.checkSliderOffset()
                }, 100)), Z.intervals.checkSliderVisibility = setInterval(function() {
                    Z.slider.checkVisibility()
                }, 500), Z.slideshow.changeTo(Z.slides.first.index))
            },
            hide: function() {
                $.addClass("ls-forcehide"), $.closest(".ls-wp-fullwidth-container").addClass("ls-forcehide"), $.closest(".ls-popup").addClass("ls-forcehide"), $.closest(".ls-popup").prev(".ls-popup-overlay").addClass("ls-forcehide")
            },
            show: function() {
                $.removeClass("ls-forcehide"), $.closest(".ls-wp-fullwidth-container").removeClass("ls-forcehide"), $.closest(".ls-popup").removeClass("ls-forcehide"), $.closest(".ls-popup").prev(".ls-popup-overlay").removeClass("ls-forcehide")
            }
        }, Z.functions = {
            convert: {
                transformOrigin: function(e, t, i, a) {
                    for (var s = (d = ee.trim(e)).split(" "), r = a[0].style, o = "", n = ["Left", "Top"], l = [Z.slider.width, Z.slider.height], d = d.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(" "), c = 0; c < d.length; c++) - 1 !== s[c].indexOf("slider") ? (Z.transitions.layers.timeline.shouldRestart = !0, o += c < 2 ? l[c] / (100 / parseInt(d[c])) - parseInt(r[n[c].toLowerCase()]) - parseInt(r["margin" + n[c]]) + "px " : "0px") : -1 !== d[c].indexOf("%") ? o += d[c] + " " : -1 !== d[c].indexOf("em") ? o += parseFloat(d[c]) * parseInt(t.css("font-size")) + "px " : o += parseInt(d[c]) * i.settings.calculatedratio + "px ";
                    return ee.trim(o)
                },
                specialValuesOfTransformOrigin: function(e) {
                    return e = e.replace("sliderleft", "0").replace("sliderright", "100%").replace("slidercenter", "50%").replace("slidermiddle", "50%").replace("slidertop", "0").replace("sliderbottom", "100%").replace("left", "0").replace("right", "100%").replace("center", "50%").replace("middle", "50%").replace("top", "0").replace("bottom", "100%").split(" ")
                },
                nodesTransformOrigin: function(e, d, c, t) {
                    for (var i = "object" == typeof e, u = (d.length, []), p = t[0].style, h = ["left", "top"], a = function(e, t) {
                            for (var t = ee(d[t]), i = parseInt(t.css("font-size")), a = t.position(), s = (n = ee.trim(e)).split(" "), r = "", o = [Z.slider.width, Z.slider.height], n = Z.functions.convert.specialValuesOfTransformOrigin(n), l = 0; l < n.length; l++) - 1 !== s[l].indexOf("slider") ? (Z.transitions.layers.timeline.shouldRestart = !0, r += l < 2 ? o[l] / (100 / parseInt(n[l])) - parseInt(a[h[l]]) - parseInt(p[h[l].toLowerCase()]) + "px " : "0px") : -1 !== n[l].indexOf("%") ? r += n[l] + " " : -1 !== n[l].indexOf("em") ? r += parseFloat(n[l]) * i + "px " : r += parseInt(n[l]) * c.settings.calculatedratio + "px ";
                            u.push(ee.trim(r))
                        }, s = 0, r = i && e.length, o = 0; o < d.length; o++) i ? (a(e[s], o), ++s == r && (s = 0)) : a(e, o);
                    return u
                },
                easing: function(e, t) {
                    return "string" != typeof e ? e : (-1 !== (e = e.toLowerCase()).indexOf("swing") || -1 !== e.indexOf("linear") ? i = J.Linear.easeNone : (a = e.match(/(easeinout|easein|easeout)(.+)/)[2], a = J[a.charAt(0).toUpperCase() + a.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);
                    var i, a
                },
                transition: function(e, t, i, a) {
                    var s = ee.extend({}, e);
                    return ee.each({
                        rotate: "rotation",
                        rotateX: "rotationX",
                        rotateY: "rotationY"
                    }, function(e, t) {
                        e in s && (s[t] = s[e], delete s[e])
                    }), "after" === i ? s.scaleX = s.scaleY = s.scaleZ = 1 : s.scale3d !== a && (s.scaleX = s.scaleY = s.scaleZ = s.scale3d, delete s.scale3d), s.delay && (s.delay = "after" === i ? s.delay / 1e3 : s.delay), void 0 === t && (t = "easeInOutQuart"), s.ease = Z.functions.convert.easing(t), s
                },
                randomProperties: function(e, t) {
                    if (e && -1 !== e.indexOf("(") && -1 !== e.indexOf(",") && -1 !== e.indexOf(")")) {
                        var i = e.split("(")[1].split(")")[0].split(","),
                            a = 1;
                        return i[0] = parseFloat(i[0]), i[1] = parseFloat(i[1]), -1 !== t.indexOf("scale") && (a = 100, i[0] *= a, i[1] *= a), Math.floor(Math.random() * (i[1] - i[0] + 1) + i[0]) / a
                    }
                    return e
                },
                properties: function(e, t) {
                    if ("string" == typeof e) return Z.functions.convert._properties(e, t);
                    if ("object" != typeof e) return e;
                    for (var i in e) e[i] = Z.functions.convert._properties(e[i], t);
                    return e
                },
                _properties: function(e, t) {
                    if ("enable" == e || "enabled" == e || "true" == e) return !0;
                    if ("disable" == e || "disabled" == e || "false" == e) return !1;
                    if ("string" != typeof e || -1 === e.indexOf(Z.defaults.init.lsDataArraySplitChar)) return t ? "" + parseInt(e) == "NaN" ? 0 : parseInt(e) : ee.isNumeric(e) ? parseFloat(e) : e;
                    for (var i = e.split(Z.defaults.init.lsDataArraySplitChar), a = [], s = 0; s < i.length; s++) a[s] = ee.isNumeric(i[s]) ? parseFloat(ee.trim(i[s])) : ee.trim(i[s]);
                    return a
                },
                oldProperties: function(i) {
                    return ee.each({
                        firstLayer: "firstSlide",
                        loops: "cycles",
                        forceLoopNum: "forceCycles",
                        layersContainer: "layersContainerWidth",
                        sublayerContainer: "layersContainerWidth",
                        randomSlideshow: "shuffleSlideshow"
                    }, function(e, t) {
                        e in i && (i[t] = i[e], delete i[e])
                    }), i
                }
            },
            getSliderClosestParentElementWithNumericValueOfProperty: function(e) {
                for (var t, i = $.parents().not(".ls-fullscreen-wrapper"), a = i.length, s = 100, r = 0; r < a; r++)
                    if ("auto" !== (t = window.getComputedStyle(i[r]).getPropertyValue(e))) {
                        if (-1 !== t.indexOf("px")) return Z.slider.$parentWithNumericWidthValue = ee(i[r]), ee(i[r]); - 1 !== t.indexOf("%") && (s = s / 100 * parseInt(t), Z.slider.$parentWithNumericWidthValuePercent = s)
                    }
            },
            sortArray: function(e, t, i) {
                var a, s, r, o, n, l = [],
                    d = e * t;
                switch (i) {
                    case "forward":
                        for (a = 0; a < e; a++)
                            for (s = 0; s < t; s++) l.push(a + s * e);
                        break;
                    case "reverse":
                        for (a = e - 1; - 1 < a; a--)
                            for (s = t - 1; - 1 < s; s--) l.push(a + s * e);
                        break;
                    case "center":
                        for (n = Math.floor(d / 2), r = 0; r < n; r++) l.push(r);
                        for (o = n; 0 <= o; o--) l.push(o);
                        break;
                    case "edge":
                    case "mirror":
                        for (r = n = Math.floor(d / 2); 0 < r; r--) l.push(r);
                        for (o = 0; o <= n; o++) l.push(o)
                }
                return l
            },
            shuffleArray: function(e) {
                for (var t, i, a = e.length; 0 !== a;) i = Math.floor(Math.random() * a), t = e[--a], e[a] = e[i], e[i] = t;
                return e
            },
            countProp: function(e) {
                var t, i = 0;
                for (t in e) e.hasOwnProperty(t) && ++i;
                return i
            },
            getURL: function(e) {
                return 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, i) {
                if (e && e.state) {
                    var a = Z.slideshow.isPaused();
                    if (i) e.state[t] = i;
                    else
                        for (var s in t) e.state[s] = t[s];
                    i = Z.slideshow.isPaused();
                    e == Z.slideshow && (Z.api.hasEvent("slideshowStateDidChange") && Z.api.triggerEvent("slideshowStateDidChange", Z.api.eventData()), i != a && (i ? Z.api.hasEvent("slideshowDidPause") && Z.api.triggerEvent("slideshowDidPause", Z.api.eventData()) : Z.api.hasEvent("slideshowDidResume") && Z.api.triggerEvent("slideshowDidResume", Z.api.eventData())))
                }
            },
            clearTimers: function() {
                for (var e in Z.timeouts) clearTimeout(Z.timeouts[e]), delete Z.timeouts[e];
                for (var t in Z.intervals) clearInterval(Z.intervals[t]), delete Z.intervals[t]
            },
            clearTimelines: function() {
                Z.transitions.timelines.set("all", function(e, t) {
                    e.pause().clear().kill(), delete Z.transitions[t]
                }), J.TweenMax.killTweensOf($.find(".ls-bg, .ls-layer, .ls-wrapper, .ls-curtile, .ls-nexttile").get())
            },
            resetSlideTimelines: function() {
                Z.transitions.timelines.set("layers", function(e, t) {
                    e.pause().progress(0).clear().kill(), delete Z.transitions[t]
                }), Z.transitions.timelines.set("allforce", function(e, t) {
                    e.pause().progress(1).clear().kill(), delete Z.transitions[t]
                }), $.find(".ls-layer:not(.ls-bg-video)").each(function() {
                    var e = ee(this).data(Z.defaults.init.dataKey);
                    e.loop._timeline && (e.loop._timeline.stop().clear(), delete e.loop._timeline, J.TweenMax.set(e.elements.$loopWrapper[0], e.reset.loopWrapperOnSlideChange)), J.TweenMax.set(e.elements.$wrapper[0], e.reset.wrapperOnSlideChange)
                })
            },
            clearEvents: function() {
                ee(window).add("body").add($).add($.find("*")).add("." + B).off("." + B + " .debug" + B + " .parallax" + B + " .scroll" + B + " .setter" + B), $.off()
            }
        }, Z.device = {
            $overflowWrapper: ee("body").length ? ee("body") : ee("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("scroll", this.preventDefault, {
                        passive: !1,
                        capture: !0
                    }), window.addEventListener("wheel", this.preventDefault, {
                        passive: !1,
                        capture: !0
                    }), window.addEventListener("mousewheel", this.preventDefault, {
                        passive: !1,
                        capture: !0
                    }), window.addEventListener("touchmove", this.preventDefault, {
                        passive: !1,
                        capture: !0
                    }), window.addEventListener("keydown", this.preventDefaultForScrollKeys, {
                        capture: !0
                    })
                },
                enable: function() {
                    window.removeEventListener("scroll", this.preventDefault, {
                        passive: !1,
                        capture: !0
                    }), window.removeEventListener("wheel", this.preventDefault, {
                        passive: !1,
                        capture: !0
                    }), window.removeEventListener("mousewheel", this.preventDefault, {
                        passive: !1,
                        capture: !0
                    }), window.removeEventListener("touchmove", this.preventDefault, {
                        passive: !1,
                        capture: !0
                    }), window.removeEventListener("keydown", this.preventDefaultForScrollKeys, {
                        capture: !0
                    })
                },
                preventDefault: function(e) {
                    (e = e || window.event).preventDefault && e.preventDefault(), e.returnValue = !1
                },
                preventDefaultForScrollKeys: function(e) {
                    if (-1 !== Z.device.scroll.keys.indexOf(e.keyCode)) return Z.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" == Z.slider.initial.type && "hero" == Z.o.fullSizeMode && (Z.slider.heroTop = Z.slider.offsetTop), Z.functions.setStates(Z.slider, {
                        inFullscreen: !0
                    }), ee("body, html").addClass("ls-fullscreen"), Z.slider.fullscreenWrapper.requestFullscreen(), $.trigger("mouseleave"), Z.device.removeSelection()
                },
                exit: function() {
                    Z.functions.setStates(Z.slider, {
                        inFullscreen: !1
                    }), Z.resize.all(), ee("body, html").removeClass("ls-fullscreen"), Z.device.removeSelection()
                },
                toggle: function() {
                    Z.device.fullscreen.element() ? (Z.device.fullscreen.exit(), document.exitFullscreen()) : Z.device.fullscreen.enter()
                },
                set: function() {
                    Z.o.allowFullscreen && (document.fullscreenEnabled || document.webkitFullscreenEnabled || document.mozFullScreenEnabled || document.msFullscreenEnabled) && ($.wrap('<div class="ls-fullscreen-wrapper"></div>'), Z.slider.$fullscreenWrapper = $.closest(".ls-fullscreen-wrapper"), Z.slider.fullscreenWrapper = Z.slider.$fullscreenWrapper[0], Z.slider.$spacingWrapper = Z.slider.$fullscreenWrapper, Z.slider.fullscreenWrapper.requestFullscreen = Z.slider.fullscreenWrapper.requestFullscreen || Z.slider.fullscreenWrapper.webkitRequestFullscreen || Z.slider.fullscreenWrapper.mozRequestFullScreen || Z.slider.fullscreenWrapper.msRequestFullscreen, document.exitFullscreen = document.exitFullscreen || document.webkitExitFullscreen || document.mozCancelFullScreen || document.msExitFullscreen, ee(document).on("fullscreenchange." + B + " webkitfullscreenchange." + B + " mozfullscreenchange." + B + " msfullscreenchange." + B, function() {
                        Z.device.fullscreen.element() || Z.device.fullscreen.exit()
                    }), Z.slider.$fullscreenWrapper.on("dblclick." + B, function() {
                        Z.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 = ee(window).width(), this.viewportHeight = ee(window).height(), this.docWidth = ee(document).width(), this.docHeight = ee(document).height(), this.winScrollTop = ee(window).scrollTop(), this.winScrollLeft = ee(window).scrollLeft(), this.ratio = this.width / this.height, this.checkSliderOffset()
            },
            checkSliderOffset: function() {
                "none" !== $.css("display") && (Z.slider.offsetTopOld = Z.slider.offsetTop || Math.round($.offset().top), Z.slider.offsetLeftOld = Z.slider.offsetLeft || Math.round($.offset().left), Z.slider.offsetTop = Math.round($.offset().top), Z.slider.offsetLeft = Math.round($.offset().left), Z.slider.offsetTopOld === Z.slider.offsetTop && Z.slider.offsetLeftOld === Z.slider.offsetLeft || (Z.resize.all(), Z.slider.check.positionToViewport(), ee(window).trigger("scroll")))
            },
            setBasicEvents: function() {
                var t, i = this;
                ee(window).on("resize.setter" + B, function() {
                    i.viewportWidth = ee(window).width(), i.viewportHeight = ee(window).height(), i.ratio = i.width / i.height, i.checkSliderOffset()
                }), ee(window).on("scroll.setter" + B, function() {
                    i.winScrollTop = ee(window).scrollTop(), i.winScrollLeft = ee(window).scrollLeft(), i.checkSliderOffset()
                }), ee(window).on("touchmove", function(e) {
                    i.winScrollTop = window.pageYOffset, i.winScrollLeft = window.pageXOffset, 1 == (t = e.touches || e.originalEvent.touches).length && (i.touchX = t[0].clientX)
                })
            }
        }, Z.actions = {
            openPopup: function(e) {
                var t, i = ee("[id^=layerslider_" + e.popup + "]").first(),
                    a = i.data("lsSliderUID");
                i.length ? ((t = window._layerSliders[a].initializedPlugins.popup).plugin.settings.showOnce = !1, "opened" == t.state.is ? e.toggle && t.events.hide() : e.slide ? i.layerSlider("fastChangeTo", e.slide, function() {
                    t.events.show()
                }) : t.events.show()) : (e = {
                    action: "ls_get_popup_markup",
                    id: e.popup,
                    slide: e.slide
                }, ee.get(Z.o.ajaxURL || window.ajaxurl || "/wp-admin/admin-ajax.php", e, function(e) {
                    ee(e).appendTo("body")
                }))
            },
            launchPopups: function() {
                for (var t in window._layerSliders) {
                    let e = window._layerSliders[t];
                    e.initializedPlugins.popup && e.api.methods("openPopup")
                }
            }
        }, Z.api = {
            hasEvent: function(e, t) {
                t = ee._data(t || I, "events");
                return !(!t || !t[e])
            },
            methods: function(e, t, i, a) {
                if (!Z.slider.isBusy())
                    if ("number" == typeof e) 0 < e && e < Z.slides.count + 1 && e != Z.slides.current.index && Z.slideshow.changeTo(e, !0, !0);
                    else switch (e) {
                        case "touchPrev":
                            Z.device.touchPrev = !0;
                        case "previousSlide":
                        case "prev":
                            Z.navigation.prev();
                            break;
                        case "touchNext":
                            Z.device.touchNext = !0;
                        case "nextSlide":
                        case "next":
                            Z.navigation.next();
                            break;
                        case "startSlideshow":
                        case "start":
                            Z.navigation.start()
                    }
                    switch (e) {
                        case "openPopup":
                            Z.initializedPlugins.popup && (t && ee.isNumeric(t) ? $.layerSlider("fastChangeTo", t, function() {
                                Z.initializedPlugins.popup.events.show()
                            }) : Z.initializedPlugins.popup.events.show());
                            break;
                        case "launchPopups":
                            Z.actions.launchPopups();
                            break;
                        case "fastChangeTo":
                            t && ee.isNumeric(t) && (Z.slides.current.index !== t ? (Z.slideshow.forceFastChange = !0, i && "function" == typeof i && (Z.slideshow.forceFastChangeCallback = i), Z.slideshow.changeTo(t, !0, !0)) : i && i());
                            break;
                        case "closePopup":
                            Z.initializedPlugins.popup && Z.initializedPlugins.popup.events.hide();
                            break;
                        case "closeAllPopups":
                            ee('<div class="ls-close-all-popups-button"></div>').css("display", "none").appendTo("body").trigger("click").remove();
                            break;
                        case "updateLayerData":
                            t && Z.layers.update.data(t, i, a);
                            break;
                        case "redrawSlider":
                        case "redraw":
                            Z.resize.all();
                            break;
                        case "replaySlide":
                        case "replay":
                            Z.transitions._slideTimeline && Z.transitions._slideTimeline.restart();
                            break;
                        case "reverseSlide":
                        case "reverse":
                            Z.transitions._slideTimeline && (Z.transitions._slideTimeline.reversed() ? Z.transitions._slideTimeline.play() : Z.transitions._slideTimeline.reverse(), t && (Z.transitions.layers.timeline.shouldReplay = !0));
                            break;
                        case "unmute":
                        case "unmuteMedia":
                            Z.media.unmute.multipleMediaElements();
                            break;
                        case "stopSlideshow":
                        case "stop":
                            Z.navigation.stop();
                            break;
                        case "pauseSlider":
                        case "pause":
                            Z.transitions._slideTimeline && Z.transitions._slideTimeline.stop(), Z.transitions._slideTransition && Z.transitions._slideTransition.stop(), Z.media.functions.stop(!1);
                            break;
                        case "resumePopup":
                            Z.layers.get("active").each(function() {
                                Z.media.functions.playIfAllowed(ee(this))
                            });
                        case "resumeSlider":
                        case "resume":
                            Z.transitions._slideTimeline && (Z.transitions._slideTimeline.timeScale() < .001 && Z.transitions.layers.timeline.resume(), Z.transitions._slideTimeline.play()), Z.transitions._slideTransition && Z.transitions._slideTransition.play();
                            break;
                        case "playMedia":
                            Z.media.functions.playActiveMedia();
                            break;
                        case "pauseMedia":
                            Z.media.functions.pauseActiveMedia();
                            break;
                        case "toggleSlider":
                        case "toggle":
                            Z.slider.state.isPaused ? ($.layerSlider("resume"), Z.slider.state.isPaused = !1) : ($.layerSlider("pause"), Z.slider.state.isPaused = !0);
                            break;
                        case "reset":
                        case "resetSlider":
                            break;
                        case "resetSlide":
                        case "resetCurrentSlide":
                            Z.transitions.timelines.set("layers", function(e, t) {
                                e.progress(0), e.stop()
                            }), Z.media.functions.stop(!0);
                            break;
                        case "destroy":
                        case "kill":
                            if (Z.slider.state.isLoaded) {
                                if (Z.functions.clearTimers(), Z.functions.clearTimelines(), Z.layers.$all.removeData(), Z.api.hasEvent("sliderDidDestroy") && Z.api.triggerEvent("sliderDidDestroy"), Z.slider.state.sholudBeRemoved || t) {
                                    if (Z.slider.$hiddenWrapper.remove(), Z.gui.timers.slidebar.$containerElement)
                                        for (var s = 0; s < Z.gui.timers.slidebar.$containerElement.length; s++) Z.gui.timers.slidebar.$containerElement[s] instanceof jQuery && Z.gui.timers.slidebar.$containerElement[s].remove();
                                    Z.api.hasEvent("sliderDidRemove") && Z.api.triggerEvent("sliderDidRemove");
                                    var r = $;
                                    r.closest(".ls-fullscreen-wrapper").length ? r = r.closest(".ls-fullscreen-wrapper") : r.closest(".ls-popup").length && (r = r.closest(".ls-popup")).prev(".ls-popup-overlay").remove(), r.remove()
                                }
                                Z.functions.clearEvents(), window._layerSlider.removeSlider(B)
                            } else Z.functions.setStates(Z.slider, {
                                shouldBeDestroyed: !0,
                                sholudBeRemoved: t || !1
                            });
                            Z.slider.positionToViewport = "under", Z.device.scroll.enable()
                    }
            },
            eventData: function() {
                return {
                    data: Z,
                    userData: Z.o,
                    uid: B,
                    target: I,
                    slider: $,
                    state: Z.slider.state,
                    isBusy: Z.slider.isBusy(),
                    event: {
                        target: I
                    },
                    api: function(e, t, i, a) {
                        $.layerSlider(e, t, i, a)
                    },
                    navigation: {
                        direction: Z.navigation.direction
                    },
                    slides: {
                        first: {
                            index: Z.slides.first.index,
                            deeplink: Z.slides.get.deeplink(Z.slides.first.index),
                            data: Z.slides.first.data
                        },
                        prev: {
                            index: Z.slides.prev.index,
                            deeplink: Z.slides.get.deeplink(Z.slides.prev.index),
                            data: Z.slides.prev.data
                        },
                        current: {
                            index: Z.slides.current.index || Z.slides.first.index,
                            deeplink: Z.slides.get.deeplink(Z.slides.current.index),
                            layersIn: Z.layers.get("current,in"),
                            layersOut: Z.layers.get("current,out"),
                            timeline: Z.transitions._slideTimeline,
                            data: Z.slides.current.data
                        },
                        next: {
                            index: Z.slides.next.index,
                            deeplink: Z.slides.get.deeplink(Z.slides.next.index),
                            layersIn: Z.layers.get("next,in"),
                            layersOut: Z.layers.get("next,out"),
                            data: Z.slides.next.data
                        },
                        count: Z.slides.count
                    },
                    slideChangeTimeline: Z.transitions._slideTransition,
                    slideshow: {
                        state: Z.slideshow.state,
                        sequence: Z.slideshow.sequence,
                        direction: Z.slideshow.direction,
                        isPaused: Z.slideshow.isPaused()
                    },
                    cycles: {
                        max: Z.o.cycles,
                        current: Z.slideshow.curCycle
                    }
                }
            },
            triggerEvent: function(t, e) {
                let i, a;
                try {
                    i = e ? (a = $.triggerHandler(t + ".layerSlider", e), $.triggerHandler(t + ".$", e)) : (a = $.triggerHandler(t + ".layerSlider"), $.triggerHandler(t + ".$"))
                } catch (e) {
                    console.error('LayerSlider: Error while calling event "' + t + '":\n\r\n\r', e)
                }
                return void 0 !== a && null !== a ? a : "undefinded" != typeof i && null !== i ? i : void 0
            }
        }, Z.browser = {
            isSafari: !!navigator.userAgent.match(/(iPhone|iPod|iPad|Safari)/i) && !navigator.userAgent.match(/(Opera|Chrome|Edge)/i),
            isChrome: function() {
                var e = window.chrome,
                    t = window.navigator,
                    i = t.vendor,
                    a = void 0 !== window.opr,
                    s = -1 < t.userAgent.indexOf("Edge"),
                    s = !!t.userAgent.match("CriOS") || null != e && "Google Inc." === i && !1 == a && !1 == s;
                return s
            },
            usesFileProtocol: -1 !== document.location.href.indexOf("file://"),
            supports3D: function() {
                for (var e = ee("<div>"), t = !1, i = !1, a = ["perspective", "OPerspective", "msPerspective", "MozPerspective", "WebkitPerspective"], s = ["transformStyle", "OTransformStyle", "msTransformStyle", "MozTransformStyle", "WebkitTransformStyle"], r = a.length - 1; 0 <= r; r--) t = t || void 0 !== e[0].style[a[r]];
                for (var o = s.length - 1; 0 <= o; o--) e.css("transform-style", "preserve-3d"), i = i || "preserve-3d" == e[0].style[s[o]];
                return t && void 0 !== e[0].style[a[4]] && (e.attr("id", "ls-test3d").appendTo($), t = 3 === e[0].offsetHeight && 9 === e[0].offsetLeft, e.remove()), t && i
            },
            isOld: -1 !== navigator.userAgent.indexOf("rident/5")
        }, Z.initializedPlugins = {}, Z.timeouts = {}, Z.intervals = {}, Z.debug = {
            options: {}
        }, Z.plugin = {
            version: "7.5.0",
            release: "stable",
            releaseDate: "2022. 09. 20."
        }, Z.slider.load()
    }
}(jQuery);
                                    

Executed Writes (0)



HTTP Transactions (82)


Request Response
                                        
                                            GET / HTTP/1.1 
Host: eicar.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Connection: keep-alive
Upgrade-Insecure-Requests: 1

                                         
                                         89.238.73.97
HTTP/1.1 301 Moved Permanently
Content-Type: text/html; charset=iso-8859-1
                                        
Date: Wed, 28 Sep 2022 12:24:10 GMT
Server: Apache
Location: https://eicar.com/
Content-Length: 226
Keep-Alive: timeout=5, max=50
Connection: Keep-Alive


--- Additional Info ---
Magic:  HTML document text\012- HTML document text\012- HTML document text\012- HTML document text\012- HTML document text\012- exported SGML document, ASCII text
Size:   226
Md5:    6913dbd2ac21dd915acf1e75c3bcc332
Sha1:   24318ab63692c4e041c3f6d50a4b980015fa5653
Sha256: 08dab9a420d00ac497b47104830ef6f755cde8f94ae798b29cf1e62231c2eb4e
                                        
                                            GET /v1/ HTTP/1.1 
Host: firefox.settings.services.mozilla.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site

                                         
                                         143.204.55.35
HTTP/1.1 200 OK
Content-Type: application/json
                                        
Content-Length: 939
Connection: keep-alive
Access-Control-Allow-Origin: *
Access-Control-Expose-Headers: Content-Length, Backoff, Content-Type, Retry-After, Alert
Cache-Control: max-age=3600
Content-Security-Policy: default-src 'none'; frame-ancestors 'none'; base-uri 'none';
Date: Wed, 28 Sep 2022 12:05:41 GMT
X-Content-Type-Options: nosniff
X-Cache: Hit from cloudfront
Via: 1.1 96c778ce6156d12f24b8b6cdaa0cbf66.cloudfront.net (CloudFront)
X-Amz-Cf-Pop: OSL50-C1
X-Amz-Cf-Id: WblD6GOnC9sts3fdVZbmpGn7Ap8QaIwtjV0UmMTkb5aLLDZdZrwW2A==
Age: 1110


--- Additional Info ---
Magic:  JSON data\012- , ASCII text, with very long lines (939), with no line terminators
Size:   939
Md5:    2d12f67fe57a87e7366b662d153a5582
Sha1:   d7b02d81cc74f24a251d9363e0f4b0a149264ec1
Sha256: 73c273c0b5a2de3cb970b8e8c187999d3b55e760dc7766dab4bb76428d19b551
                                        
                                            POST / HTTP/1.1 
Host: r3.o.lencr.org
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Content-Type: application/ocsp-request
Content-Length: 85
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache

                                         
                                         23.36.76.226
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Server: nginx
Content-Length: 503
ETag: "2A40F957A6B1734AA3F87CFF51B673F0536732DB15B09033DD604879692DF349"
Last-Modified: Tue, 27 Sep 2022 21:00:00 UTC
Cache-Control: public, no-transform, must-revalidate, max-age=11259
Expires: Wed, 28 Sep 2022 15:31:50 GMT
Date: Wed, 28 Sep 2022 12:24:11 GMT
Connection: keep-alive

                                        
                                            GET /chains/remote-settings.content-signature.mozilla.org-2022-10-30-18-47-44.chain HTTP/1.1 
Host: content-signature-2.cdn.mozilla.net
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: cross-site

                                         
                                         143.204.55.35
HTTP/2 200 OK
content-type: binary/octet-stream
                                        
content-length: 5348
last-modified: Sat, 10 Sep 2022 18:47:45 GMT
content-disposition: attachment
accept-ranges: bytes
server: AmazonS3
date: Wed, 28 Sep 2022 09:24:14 GMT
etag: "6113f8408c59aebe188d6af273b90743"
x-cache: Hit from cloudfront
via: 1.1 aa34a836095df9de9d246a53dd63f1d6.cloudfront.net (CloudFront)
x-amz-cf-pop: OSL50-C1
x-amz-cf-id: RvGn-1HKf3KoP-Pp59B1I2UQkfekkIw5AMc9h89d3IqODypkHdZLog==
age: 24945
X-Firefox-Spdy: h2


--- Additional Info ---
Magic:  PEM certificate\012- , ASCII text
Size:   5348
Md5:    6113f8408c59aebe188d6af273b90743
Sha1:   7398873bf00f99944eaa77ad3ebc0d43c23dba6b
Sha256: b6e0cc9ad68306208a160f3835fb8da76acc5a82d8fde1da5a98e1de1c11a770
                                        
                                            GET /v1/tiles HTTP/1.1 
Host: contile.services.mozilla.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site

                                         
                                         34.117.237.239
HTTP/2 200 OK
content-type: application/json
                                        
server: nginx
date: Wed, 28 Sep 2022 12:24:11 GMT
content-length: 12
strict-transport-security: max-age=31536000
via: 1.1 google
alt-svc: clear
X-Firefox-Spdy: h2


--- Additional Info ---
Magic:  JSON data\012- , ASCII text, with no line terminators
Size:   12
Md5:    23e88fb7b99543fb33315b29b1fad9d6
Sha1:   a48926c4ec03c7c8a4e8dffcd31e5a6cdda417ce
Sha256: 7d8f1de8b7de7bc21dfb546a1d0c51bf31f16eee5fad49dbceae1e76da38e5c3
                                        
                                            POST / HTTP/1.1 
Host: r3.o.lencr.org
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Content-Type: application/ocsp-request
Content-Length: 85
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache

                                         
                                         23.36.76.226
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Server: nginx
Content-Length: 503
ETag: "ECA4A1B0AC0366D3018EFDC037D5D8FAEEE43C34805892CF1A9BEFBBA7C98AAB"
Last-Modified: Tue, 27 Sep 2022 08:00:00 UTC
Cache-Control: public, no-transform, must-revalidate, max-age=21596
Expires: Wed, 28 Sep 2022 18:24:07 GMT
Date: Wed, 28 Sep 2022 12:24:11 GMT
Connection: keep-alive

                                        
                                            GET /v1/buckets/main/collections/ms-language-packs/records/cfr-v1-en-US HTTP/1.1 
Host: firefox.settings.services.mozilla.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: application/json
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Content-Type: application/json
Connection: keep-alive
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site

                                         
                                         143.204.55.35
HTTP/1.1 200 OK
Content-Type: application/json
                                        
Content-Length: 329
Connection: keep-alive
Access-Control-Allow-Origin: *
Access-Control-Expose-Headers: ETag, Expires, Content-Length, Cache-Control, Pragma, Content-Type, Alert, Backoff, Last-Modified, Retry-After
Content-Security-Policy: default-src 'none'; frame-ancestors 'none'; base-uri 'none';
Last-Modified: Fri, 25 Mar 2022 17:45:46 GMT
Strict-Transport-Security: max-age=31536000
X-Content-Type-Options: nosniff
Date: Wed, 28 Sep 2022 11:29:33 GMT
Cache-Control: max-age=3600, max-age=3600
Expires: Wed, 28 Sep 2022 12:03:34 GMT
ETag: "1648230346554"
X-Cache: Hit from cloudfront
Via: 1.1 bcd5dadccb0831729969c938747ff79a.cloudfront.net (CloudFront)
X-Amz-Cf-Pop: OSL50-C1
X-Amz-Cf-Id: D_QhR1oQvtoRMiAXGe3fHAexRZqf2uosjHquz1p8KSUwf576nGicLQ==
Age: 3278


--- Additional Info ---
Magic:  JSON data\012- , ASCII text, with very long lines (329), with no line terminators
Size:   329
Md5:    0333b0655111aa68de771adfcc4db243
Sha1:   63f295a144ac87a7c8e23417626724eeca68a7eb
Sha256: 60636eb1dc67c9ed000fe0b49f03777ad6f549cb1d2b9ff010cf198465ae6300
                                        
                                            POST / HTTP/1.1 
Host: ocsp.digicert.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Content-Type: application/ocsp-request
Content-Length: 83
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache

                                         
                                         93.184.220.29
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Accept-Ranges: bytes
Age: 3749
Cache-Control: 'max-age=158059'
Date: Wed, 28 Sep 2022 12:24:12 GMT
Last-Modified: Wed, 28 Sep 2022 11:21:43 GMT
Server: ECS (ska/F711)
X-Cache: HIT
Content-Length: 471

                                        
                                            GET / HTTP/1.1 
Host: eicar.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Upgrade-Insecure-Requests: 1
Sec-Fetch-Dest: document
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: none
Sec-Fetch-User: ?1

                                         
                                         89.238.73.97
HTTP/1.1 301 Moved Permanently
Content-Type: text/html; charset=UTF-8
                                        
Date: Wed, 28 Sep 2022 12:24:10 GMT
Server: Apache
Expires: Thu, 19 Nov 1981 08:52:00 GMT
Pragma: no-cache
X-Redirect-By: WordPress
Set-Cookie: __wpdm_client=c11170dca089cc3d7eb6d01a7f1a1068; secure; HttpOnly PHPSESSID=mfopucvurfdp6hrir2793h0jdj; path=/
Location: https://www.eicar.com/
Strict-Transport-Security: max-age=31536000; includeSubDomains; preload
Cache-Control: no-store, no-cache, must-revalidate, public
Content-Length: 0
Keep-Alive: timeout=5, max=50
Connection: Keep-Alive

                                        
                                            GET / HTTP/1.1 
Host: push.services.mozilla.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Sec-WebSocket-Version: 13
Origin: wss://push.services.mozilla.com/
Sec-WebSocket-Protocol: push-notification
Sec-WebSocket-Extensions: permessage-deflate
Sec-WebSocket-Key: XUaSUEEZzbIdIY5z50tvrw==
Connection: keep-alive, Upgrade
Sec-Fetch-Dest: websocket
Sec-Fetch-Mode: websocket
Sec-Fetch-Site: cross-site
Pragma: no-cache
Cache-Control: no-cache
Upgrade: websocket

                                         
                                         35.162.217.251
HTTP/1.1 101 Switching Protocols
                                        
Connection: Upgrade
Upgrade: websocket
Sec-WebSocket-Accept: nCnhJ07pOgpccRt/VqhazaHjLSY=

                                        
                                            POST / HTTP/1.1 
Host: r3.o.lencr.org
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Content-Type: application/ocsp-request
Content-Length: 85
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache

                                         
                                         23.36.76.226
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Server: nginx
Content-Length: 503
ETag: "236ECE2FC1F87B8BAB389248195E20EA4CB1934BC1FD1C7E98C5A329A84ADAB8"
Last-Modified: Wed, 28 Sep 2022 08:00:00 UTC
Cache-Control: public, no-transform, must-revalidate, max-age=18766
Expires: Wed, 28 Sep 2022 17:36:58 GMT
Date: Wed, 28 Sep 2022 12:24:12 GMT
Connection: keep-alive

                                        
                                            POST / HTTP/1.1 
Host: r3.o.lencr.org
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Content-Type: application/ocsp-request
Content-Length: 85
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache

                                         
                                         23.36.76.226
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Server: nginx
Content-Length: 503
ETag: "A37AFAFC8EE712AE7AE935D3ED564F3CF46DD09005DEBBC5E2650F8B434D1E00"
Last-Modified: Tue, 27 Sep 2022 21:00:00 UTC
Cache-Control: public, no-transform, must-revalidate, max-age=10648
Expires: Wed, 28 Sep 2022 15:21:41 GMT
Date: Wed, 28 Sep 2022 12:24:13 GMT
Connection: keep-alive

                                        
                                            POST / HTTP/1.1 
Host: r3.o.lencr.org
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Content-Type: application/ocsp-request
Content-Length: 85
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache

                                         
                                         23.36.76.226
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Server: nginx
Content-Length: 503
ETag: "A37AFAFC8EE712AE7AE935D3ED564F3CF46DD09005DEBBC5E2650F8B434D1E00"
Last-Modified: Tue, 27 Sep 2022 21:00:00 UTC
Cache-Control: public, no-transform, must-revalidate, max-age=10648
Expires: Wed, 28 Sep 2022 15:21:41 GMT
Date: Wed, 28 Sep 2022 12:24:13 GMT
Connection: keep-alive

                                        
                                            POST / HTTP/1.1 
Host: r3.o.lencr.org
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Content-Type: application/ocsp-request
Content-Length: 85
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache

                                         
                                         23.36.76.226
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Server: nginx
Content-Length: 503
ETag: "A37AFAFC8EE712AE7AE935D3ED564F3CF46DD09005DEBBC5E2650F8B434D1E00"
Last-Modified: Tue, 27 Sep 2022 21:00:00 UTC
Cache-Control: public, no-transform, must-revalidate, max-age=10648
Expires: Wed, 28 Sep 2022 15:21:41 GMT
Date: Wed, 28 Sep 2022 12:24:13 GMT
Connection: keep-alive

                                        
                                            GET /296x148/filters:format(jpeg):quality(60):no_upscale():strip_exif()/https%3A%2F%2Fs3.amazonaws.com%2Fpocket-curatedcorpusapi-prod-images%2F693de74c-173e-4d9b-8317-35601f30ffd7.jpeg HTTP/1.1 
Host: img-getpocket.cdn.mozilla.net
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: image/avif,image/webp,*/*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Origin: null
Connection: keep-alive
Sec-Fetch-Dest: image
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site

                                         
                                         34.120.237.76
HTTP/2 200 OK
content-type: image/jpeg
                                        
server: nginx
content-length: 13299
x-amzn-requestid: 926df8b6-beec-470d-b0b3-33be326cd379
x-xss-protection: 1; mode=block
access-control-allow-origin: *
strict-transport-security: max-age=63072000; includeSubdomains; preload
x-frame-options: DENY
content-security-policy: default-src 'none'; img-src 'self'; script-src 'self'; style-src 'self'; object-src 'none'
x-amz-apigw-id: ZI3UPF8YIAMF3Nw=
x-content-type-options: nosniff
x-amzn-trace-id: Root=1-63336c1a-343e91e735af43d01fc83ddd;Sampled=0
x-amzn-remapped-date: Tue, 27 Sep 2022 21:33:14 GMT
x-amz-cf-pop: HIO50-C1, SEA73-P1
x-cache: Miss from cloudfront
x-amz-cf-id: fcxclGRP3zfWwb6opjYU2bL9VAq_mCSNjFtfp9iMLq6tbZu57EDqpQ==
via: 1.1 e5af640ced3aa8764b82c4bc3f7af38e.cloudfront.net (CloudFront), 1.1 2324edbcb8fc72f617442c65f36a40fc.cloudfront.net (CloudFront), 1.1 google
date: Tue, 27 Sep 2022 21:50:04 GMT
etag: "651600f2ef18cecc2e38370069bbb5e1d86f68e0"
age: 52449
cache-control: max-age=3600,public,public
alt-svc: clear
X-Firefox-Spdy: h2


--- Additional Info ---
Magic:  JPEG image data, JFIF standard 1.01, aspect ratio, density 1x1, segment length 16, progressive, precision 8, 296x148, components 3\012- data
Size:   13299
Md5:    ad84ed0c5b2090df7996007514cf1984
Sha1:   651600f2ef18cecc2e38370069bbb5e1d86f68e0
Sha256: a3d0729e1d43afeadd2dd8273c858b8839d9e476f773c8ec9d96b5969a9e0b4a
                                        
                                            GET /296x148/filters:format(jpeg):quality(60):no_upscale():strip_exif()/https%3A%2F%2Fs3.amazonaws.com%2Fpocket-curatedcorpusapi-prod-images%2F8ffa6dde-b51e-43f8-bfcb-3f442d674928.jpeg HTTP/1.1 
Host: img-getpocket.cdn.mozilla.net
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: image/avif,image/webp,*/*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Origin: null
Connection: keep-alive
Sec-Fetch-Dest: image
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site

                                         
                                         34.120.237.76
HTTP/2 200 OK
content-type: image/jpeg
                                        
server: nginx
content-length: 8500
x-amzn-requestid: 626c21ec-f29b-4b69-b275-c22c864c2409
x-xss-protection: 1; mode=block
access-control-allow-origin: *
strict-transport-security: max-age=63072000; includeSubdomains; preload
x-frame-options: DENY
content-security-policy: default-src 'none'; img-src 'self'; script-src 'self'; style-src 'self'; object-src 'none'
x-amz-apigw-id: ZI3VmENnIAMFeTQ=
x-content-type-options: nosniff
x-amzn-trace-id: Root=1-63336c23-75eccc381fbd6e5d4ff59c06;Sampled=0
x-amzn-remapped-date: Tue, 27 Sep 2022 21:33:23 GMT
x-amz-cf-pop: HIO50-C1, SEA73-P1
x-cache: Miss from cloudfront
x-amz-cf-id: Eyy8qoYVCJbt6b6hTGJ-rOrYex9RuX1InyZbpHkeu9yQqPUEvowKcw==
via: 1.1 da5952aa802df39905ceb16592e9698a.cloudfront.net (CloudFront), 1.1 09331f0822fc98eebaf04130a83dbd44.cloudfront.net (CloudFront), 1.1 google
date: Tue, 27 Sep 2022 21:48:58 GMT
etag: "9c4692ea64832895fbd107d91f879728b6a440c7"
age: 52515
cache-control: max-age=3600,public,public
alt-svc: clear
X-Firefox-Spdy: h2


--- Additional Info ---
Magic:  JPEG image data, JFIF standard 1.01, aspect ratio, density 1x1, segment length 16, progressive, precision 8, 296x148, components 3\012- data
Size:   8500
Md5:    6139c878a7d2bd32c61fc8287996eb5b
Sha1:   9c4692ea64832895fbd107d91f879728b6a440c7
Sha256: 3839df92f0a10c1433d5b576df50c9f7953912ae4f425012262f08ee8a59ce2e
                                        
                                            GET /296x148/filters:format(jpeg):quality(60):no_upscale():strip_exif()/https%3A%2F%2Fs3.amazonaws.com%2Fpocket-curatedcorpusapi-prod-images%2F79631135-a10c-43bf-85d2-fa2236b96883.jpeg HTTP/1.1 
Host: img-getpocket.cdn.mozilla.net
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: image/avif,image/webp,*/*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Origin: null
Connection: keep-alive
Sec-Fetch-Dest: image
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site

                                         
                                         34.120.237.76
HTTP/2 200 OK
content-type: image/jpeg
                                        
server: nginx
content-length: 13213
x-amzn-requestid: 09f8fee2-6830-4bec-af40-f2fb6547bc63
x-xss-protection: 1; mode=block
access-control-allow-origin: *
strict-transport-security: max-age=63072000; includeSubdomains; preload
x-frame-options: DENY
content-security-policy: default-src 'none'; img-src 'self'; script-src 'self'; style-src 'self'; object-src 'none'
x-amz-apigw-id: ZFkreH5poAMFdxg=
x-content-type-options: nosniff
x-amzn-trace-id: Root=1-63321b16-0afbf5e01a013e6f0db53da1;Sampled=0
x-amzn-remapped-date: Mon, 26 Sep 2022 21:35:18 GMT
x-amz-cf-pop: SEA73-P1
x-cache: Miss from cloudfront
x-amz-cf-id: CwkfEPDseHez7mArqwz8tmC3WHFwXAZF1OSColucaQ5vG2hvBIDWOg==
via: 1.1 0c96ded7ff282d2dbcf47c918b6bb500.cloudfront.net (CloudFront), 1.1 28390a4d24ed4fdccd685d99cd06cf4e.cloudfront.net (CloudFront), 1.1 google
date: Tue, 27 Sep 2022 21:39:01 GMT
age: 53112
etag: "3d4fa8701f17e8818c25584ef5f04bfbee8440cd"
cache-control: max-age=3600,public,public
alt-svc: clear
X-Firefox-Spdy: h2


--- Additional Info ---
Magic:  JPEG image data, JFIF standard 1.01, aspect ratio, density 1x1, segment length 16, progressive, precision 8, 296x148, components 3\012- data
Size:   13213
Md5:    62e68c3cd08dd94d910507512a67e85f
Sha1:   3d4fa8701f17e8818c25584ef5f04bfbee8440cd
Sha256: 058d798963f83f5fb88ab728185f755c5353fa981d93e1b6ff869089f501586b
                                        
                                            GET /296x148/filters:format(jpeg):quality(60):no_upscale():strip_exif()/https%3A%2F%2Fs3.amazonaws.com%2Fpocket-curatedcorpusapi-prod-images%2Fad593ee0-d404-46e3-b129-229e09b263b0.png HTTP/1.1 
Host: img-getpocket.cdn.mozilla.net
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: image/avif,image/webp,*/*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Origin: null
Connection: keep-alive
Sec-Fetch-Dest: image
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site

                                         
                                         34.120.237.76
HTTP/2 200 OK
content-type: image/jpeg
                                        
server: nginx
content-length: 12016
x-amzn-requestid: ec1b3715-5d0f-4045-aa5b-b70a55c81d72
x-xss-protection: 1; mode=block
access-control-allow-origin: *
strict-transport-security: max-age=63072000; includeSubdomains; preload
x-frame-options: DENY
content-security-policy: default-src 'none'; img-src 'self'; script-src 'self'; style-src 'self'; object-src 'none'
x-amz-apigw-id: ZI3e3EtyIAMFdZg=
x-content-type-options: nosniff
x-amzn-trace-id: Root=1-63336c5e-201dd1ef1426a09965c68dab;Sampled=0
x-amzn-remapped-date: Tue, 27 Sep 2022 21:34:22 GMT
x-amz-cf-pop: HIO50-C1, SEA19-C2
x-cache: Hit from cloudfront
x-amz-cf-id: pR4b1-lZZRMnWf-PdXFGXaHBCGAfOyp3AjeuCvtu5imWmf9N9l2wKQ==
via: 1.1 41e349e25dc4bc856d0e5d2c162428a0.cloudfront.net (CloudFront), 1.1 be082a2326b7d49643607b097f1e7180.cloudfront.net (CloudFront), 1.1 google
date: Tue, 27 Sep 2022 21:48:38 GMT
age: 52535
etag: "a54803cca7d3c509c195f65961e1110c8ec56f55"
cache-control: max-age=3600,public,public
alt-svc: clear
X-Firefox-Spdy: h2


--- Additional Info ---
Magic:  JPEG image data, JFIF standard 1.01, aspect ratio, density 1x1, segment length 16, progressive, precision 8, 296x148, components 3\012- data
Size:   12016
Md5:    4b794c6812cb546de0295e087ebe66a7
Sha1:   a54803cca7d3c509c195f65961e1110c8ec56f55
Sha256: 6a207f75eb3951f3dea5252bc8d185cd604d3d657f15b838774e8087e91f37f5
                                        
                                            GET /296x148/filters:format(jpeg):quality(60):no_upscale():strip_exif()/https%3A%2F%2Fs3.amazonaws.com%2Fpocket-curatedcorpusapi-prod-images%2F7cfd0596-5b8b-4a41-a6fb-93e46d7eebaf.jpeg HTTP/1.1 
Host: img-getpocket.cdn.mozilla.net
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: image/avif,image/webp,*/*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Origin: null
Connection: keep-alive
Sec-Fetch-Dest: image
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site

                                         
                                         34.120.237.76
HTTP/2 200 OK
content-type: image/jpeg
                                        
server: nginx
content-length: 10593
x-amzn-requestid: 165366e6-f7b6-4087-9370-1b4e413da9fb
x-xss-protection: 1; mode=block
access-control-allow-origin: *
strict-transport-security: max-age=63072000; includeSubdomains; preload
x-frame-options: DENY
content-security-policy: default-src 'none'; img-src 'self'; script-src 'self'; style-src 'self'; object-src 'none'
x-amz-apigw-id: ZI3VRFKzoAMFuOw=
x-content-type-options: nosniff
x-amzn-trace-id: Root=1-63336c21-6bf91447296a7b09770dc2fd;Sampled=0
x-amzn-remapped-date: Tue, 27 Sep 2022 21:33:21 GMT
x-amz-cf-pop: SEA73-P2, SEA73-P1
x-cache: Miss from cloudfront
x-amz-cf-id: nih2VrFo_PgmAUnv6VpsLiSAhaHqQKNIt4jY_NGKOToa7MRMMH7Ubw==
via: 1.1 34c44cb7892e57a3b6c51812bcf68ee4.cloudfront.net (CloudFront), 1.1 cd858042f70b416ca05e042acf3908a4.cloudfront.net (CloudFront), 1.1 google
date: Tue, 27 Sep 2022 21:48:58 GMT
etag: "d311aa07fe9e05f84f6bcc4320c7bea6b95dd202"
age: 52515
cache-control: max-age=3600,public,public
alt-svc: clear
X-Firefox-Spdy: h2


--- Additional Info ---
Magic:  JPEG image data, JFIF standard 1.01, aspect ratio, density 1x1, segment length 16, progressive, precision 8, 296x148, components 3\012- data
Size:   10593
Md5:    d569b3ae8d704ad9100ba4f11a632cb8
Sha1:   d311aa07fe9e05f84f6bcc4320c7bea6b95dd202
Sha256: 3425f374243fabdd434e2b555ec1561dd91c2bedbc187cf5c49ce38b4b7642da
                                        
                                            GET /296x148/filters:format(jpeg):quality(60):no_upscale():strip_exif()/https%3A%2F%2Fs3.amazonaws.com%2Fpocket-curatedcorpusapi-prod-images%2F0369629e-f44d-439f-a279-b5ae6ecc0cf1.png HTTP/1.1 
Host: img-getpocket.cdn.mozilla.net
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: image/avif,image/webp,*/*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Origin: null
Connection: keep-alive
Sec-Fetch-Dest: image
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site

                                         
                                         34.120.237.76
HTTP/2 200 OK
content-type: image/jpeg
                                        
server: nginx
content-length: 14464
x-amzn-requestid: 5cbbafdb-3f69-4ee2-9e46-c1ff0ed4ef14
x-xss-protection: 1; mode=block
access-control-allow-origin: *
strict-transport-security: max-age=63072000; includeSubdomains; preload
x-frame-options: DENY
content-security-policy: default-src 'none'; img-src 'self'; script-src 'self'; style-src 'self'; object-src 'none'
x-amz-apigw-id: ZI3UPFiooAMFulA=
x-content-type-options: nosniff
x-amzn-trace-id: Root=1-63336c1a-633a649700e040b91deadb64;Sampled=0
x-amzn-remapped-date: Tue, 27 Sep 2022 21:33:14 GMT
x-amz-cf-pop: HIO50-C1, SEA73-P1
x-cache: Miss from cloudfront
x-amz-cf-id: cNryG5vkxZuFATZfcNW9Z1-0teUBWLRyWslX1onwYlDCQBUjU2xVdA==
via: 1.1 9b311162717b41c968f6f00426d88aaa.cloudfront.net (CloudFront), 1.1 73cb83fe6699afc2791b5c690c1ff8c6.cloudfront.net (CloudFront), 1.1 google
date: Tue, 27 Sep 2022 21:46:03 GMT
age: 52690
etag: "bc214d60be395d4cf753216ff8f9691c33d25e75"
cache-control: max-age=3600,public,public
alt-svc: clear
X-Firefox-Spdy: h2


--- Additional Info ---
Magic:  JPEG image data, JFIF standard 1.01, aspect ratio, density 1x1, segment length 16, progressive, precision 8, 296x148, components 3\012- data
Size:   14464
Md5:    aa5cad224dbddd71881bd07255beb4da
Sha1:   bc214d60be395d4cf753216ff8f9691c33d25e75
Sha256: 82935e52aa59929a448d17a5a2d58fda86bb5c25bf6628a05bd904f82517dada
                                        
                                            GET / HTTP/1.1 
Host: www.eicar.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Upgrade-Insecure-Requests: 1
Sec-Fetch-Dest: document
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: none
Sec-Fetch-User: ?1

                                         
                                         89.238.73.97
HTTP/1.1 200 OK
Content-Type: text/html; charset=UTF-8
                                        
Date: Wed, 28 Sep 2022 12:24:11 GMT
Server: Apache
Expires: Thu, 19 Nov 1981 08:52:00 GMT
Pragma: no-cache
Link: <https://www.eicar.com/wp-json/>; rel="https://api.w.org/", <https://www.eicar.com/wp-json/wp/v2/pages/102>; rel="alternate"; type="application/json", <https://www.eicar.com/>; rel=shortlink
Set-Cookie: __wpdm_client=c11170dca089cc3d7eb6d01a7f1a1068; secure; HttpOnly PHPSESSID=ieqprb25m18drt6ib4avksniff; path=/
Vary: Accept-Encoding
Content-Encoding: gzip
Strict-Transport-Security: max-age=31536000; includeSubDomains
Cache-Control: no-store, no-cache, must-revalidate, public
Content-Length: 25769
Keep-Alive: timeout=5, max=50
Connection: Keep-Alive


--- Additional Info ---
Magic:  HTML document text\012- HTML document text\012- HTML document text\012- HTML document text\012- HTML document text\012- exported SGML document, Unicode text, UTF-8 text, with very long lines (28555)
Size:   25769
Md5:    433df4c63f75f18d5a46dd901f3bd586
Sha1:   9032f05aa6903d26c20ea8d756acc33ade52697e
Sha256: c4ad3157d1aad9c0da5e2efce03d85aebc08cf32bd88de18fb7c322210cacc03
                                        
                                            POST / HTTP/1.1 
Host: ocsp.digicert.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Content-Type: application/ocsp-request
Content-Length: 83
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache

                                         
                                         93.184.220.29
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Accept-Ranges: bytes
Age: 6308
Cache-Control: 'max-age=158059'
Date: Wed, 28 Sep 2022 12:24:14 GMT
Last-Modified: Wed, 28 Sep 2022 10:39:06 GMT
Server: ECS (ska/F711)
X-Cache: HIT
Content-Length: 471

                                        
                                            POST / HTTP/1.1 
Host: ocsp.digicert.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Content-Type: application/ocsp-request
Content-Length: 83
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache

                                         
                                         93.184.220.29
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Accept-Ranges: bytes
Age: 5012
Cache-Control: 'max-age=158059'
Date: Wed, 28 Sep 2022 12:24:14 GMT
Last-Modified: Wed, 28 Sep 2022 11:00:42 GMT
Server: ECS (ska/F711)
X-Cache: HIT
Content-Length: 277

                                        
                                            GET /wp-content/cache/autoptimize/css/autoptimize_e3c75247f16ed8dabe4caa8b6fd93df9.css HTTP/1.1 
Host: www.eicar.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: text/css,*/*;q=0.1
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/
Cookie: __wpdm_client=c11170dca089cc3d7eb6d01a7f1a1068; PHPSESSID=ieqprb25m18drt6ib4avksniff
Sec-Fetch-Dest: style
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: same-origin

                                         
                                         89.238.73.97
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Date: Wed, 28 Sep 2022 12:24:13 GMT
Server: Apache
Last-Modified: Thu, 22 Sep 2022 20:39:37 GMT
ETag: "4f8f-5e94a0f540db0-gzip"
Accept-Ranges: bytes
Cache-Control: max-age=31536000 public
Expires: Mon, 18 Sep 2023 12:24:13 GMT
Vary: Accept-Encoding
Content-Encoding: gzip
Strict-Transport-Security: max-age=31536000; includeSubDomains
Content-Length: 4216
Keep-Alive: timeout=5, max=50
Connection: Keep-Alive


--- Additional Info ---
Magic:  ASCII text, with very long lines (20367), with no line terminators
Size:   4216
Md5:    48f3cf8799de0e60ce8a1b226b6e8db1
Sha1:   23f898f588389b00944adea0a1f22fca496197b3
Sha256: dd91285d13241a5ecd3ed5d8e426c01a7d93042126d920c37b5a16597c1178cc
                                        
                                            POST / HTTP/1.1 
Host: ocsp.digicert.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Content-Type: application/ocsp-request
Content-Length: 83
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache

                                         
                                         93.184.220.29
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Accept-Ranges: bytes
Age: 5012
Cache-Control: 'max-age=158059'
Date: Wed, 28 Sep 2022 12:24:14 GMT
Last-Modified: Wed, 28 Sep 2022 11:00:42 GMT
Server: ECS (ska/F711)
X-Cache: HIT
Content-Length: 277

                                        
                                            GET /wp-includes/js/dist/vendor/regenerator-runtime.min.js HTTP/1.1 
Host: www.eicar.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/
Cookie: __wpdm_client=c11170dca089cc3d7eb6d01a7f1a1068; PHPSESSID=ieqprb25m18drt6ib4avksniff
Sec-Fetch-Dest: script
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: same-origin

                                         
                                         89.238.73.97
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Wed, 28 Sep 2022 12:24:13 GMT
Server: Apache
Last-Modified: Tue, 24 May 2022 21:00:13 GMT
ETag: "194b-5dfc83e34c877-gzip"
Accept-Ranges: bytes
Cache-Control: max-age=31536000, private
Expires: Thu, 28 Sep 2023 12:24:13 GMT
Vary: Accept-Encoding
Content-Encoding: gzip
Strict-Transport-Security: max-age=31536000; includeSubDomains
Content-Length: 2457
Keep-Alive: timeout=5, max=50
Connection: Keep-Alive


--- Additional Info ---
Magic:  ASCII text, with very long lines (6475), with no line terminators
Size:   2457
Md5:    27cbbd0a9d7c5ad9402118c4afc36035
Sha1:   7659d08a005f5ecfa6c779e3cda45c30007fd059
Sha256: ebc771d0af626966e38535357861fab0090e0bd7ff346cbe3c7ffdde1683809f
                                        
                                            GET /wp-includes/js/dist/hooks.min.js HTTP/1.1 
Host: www.eicar.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/
Cookie: __wpdm_client=c11170dca089cc3d7eb6d01a7f1a1068; PHPSESSID=ieqprb25m18drt6ib4avksniff
Sec-Fetch-Dest: script
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: same-origin

                                         
                                         89.238.73.97
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Wed, 28 Sep 2022 12:24:13 GMT
Server: Apache
Last-Modified: Tue, 24 May 2022 21:00:13 GMT
ETag: "132e-5dfc83e34e7b7-gzip"
Accept-Ranges: bytes
Cache-Control: max-age=31536000, private
Expires: Thu, 28 Sep 2023 12:24:13 GMT
Vary: Accept-Encoding
Content-Encoding: gzip
Strict-Transport-Security: max-age=31536000; includeSubDomains
Content-Length: 1661
Keep-Alive: timeout=5, max=50
Connection: Keep-Alive


--- Additional Info ---
Magic:  ASCII text, with very long lines (4875)
Size:   1661
Md5:    320b86bb1a9ce650a5e3553b2bb1c430
Sha1:   c56e8668b398641ed5cdcfbd8a8eba7d631cdb9c
Sha256: c9ebbb8d122c6be3880d18172abfe308bb07db900689484fa765a73b8b20b3ec
                                        
                                            GET /wp-includes/js/dist/vendor/wp-polyfill.min.js HTTP/1.1 
Host: www.eicar.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/
Cookie: __wpdm_client=c11170dca089cc3d7eb6d01a7f1a1068; PHPSESSID=ieqprb25m18drt6ib4avksniff
Sec-Fetch-Dest: script
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: same-origin

                                         
                                         89.238.73.97
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Wed, 28 Sep 2022 12:24:13 GMT
Server: Apache
Last-Modified: Tue, 24 May 2022 21:00:13 GMT
ETag: "4ac6-5dfc83e34b8d7-gzip"
Accept-Ranges: bytes
Cache-Control: max-age=31536000, private
Expires: Thu, 28 Sep 2023 12:24:13 GMT
Vary: Accept-Encoding
Content-Encoding: gzip
Strict-Transport-Security: max-age=31536000; includeSubDomains
Content-Length: 7095
Keep-Alive: timeout=5, max=50
Connection: Keep-Alive


--- Additional Info ---
Magic:  Unicode text, UTF-8 text, with very long lines (19138), with no line terminators
Size:   7095
Md5:    2f4fcc5a628b379672d76b7e91cbdf07
Sha1:   9d72f2c9cbc1e9b036360acfce8c8ccc8b832b8c
Sha256: a360f715a418026d2e1acd81c02c83233d0c0b60fdf4ce0b4d33562925d6a0b5
                                        
                                            GET /wp-includes/js/dist/i18n.min.js HTTP/1.1 
Host: www.eicar.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/
Cookie: __wpdm_client=c11170dca089cc3d7eb6d01a7f1a1068; PHPSESSID=ieqprb25m18drt6ib4avksniff
Sec-Fetch-Dest: script
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: same-origin

                                         
                                         89.238.73.97
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Wed, 28 Sep 2022 12:24:13 GMT
Server: Apache
Last-Modified: Tue, 24 May 2022 21:00:13 GMT
ETag: "27ee-5dfc83e3506f7-gzip"
Accept-Ranges: bytes
Cache-Control: max-age=31536000, private
Expires: Thu, 28 Sep 2023 12:24:13 GMT
Vary: Accept-Encoding
Content-Encoding: gzip
Strict-Transport-Security: max-age=31536000; includeSubDomains
Content-Length: 3865
Keep-Alive: timeout=5, max=49
Connection: Keep-Alive


--- Additional Info ---
Magic:  data
Size:   3865
Md5:    ca0cf10a1d933e4262c732da8f9008c1
Sha1:   d6fdc041e650cf096841671884db8854490dba72
Sha256: fbd145cb64d3185e42b8a3f6fff22b3e4cc3550934b63a4f874c21c44f920702
                                        
                                            GET /wp-includes/js/jquery/jquery.min.js HTTP/1.1 
Host: www.eicar.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/
Cookie: __wpdm_client=c11170dca089cc3d7eb6d01a7f1a1068; PHPSESSID=ieqprb25m18drt6ib4avksniff
Sec-Fetch-Dest: script
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: same-origin

                                         
                                         89.238.73.97
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Wed, 28 Sep 2022 12:24:13 GMT
Server: Apache
Last-Modified: Wed, 10 Mar 2021 15:07:24 GMT
ETag: "15db1-5bd3006388300-gzip"
Accept-Ranges: bytes
Cache-Control: max-age=31536000, private
Expires: Thu, 28 Sep 2023 12:24:13 GMT
Vary: Accept-Encoding
Content-Encoding: gzip
Strict-Transport-Security: max-age=31536000; includeSubDomains
Content-Length: 30908
Keep-Alive: timeout=5, max=50
Connection: Keep-Alive


--- Additional Info ---
Magic:  ASCII text, with very long lines (65447)
Size:   30908
Md5:    9640915738503451aa21181699feab5b
Sha1:   c053eaf36ef0da96619706b3abda326305063bd6
Sha256: f8834e669ad1f4039442c26aaa373ec39c35a233b9786d374fc3f670f16b0adc
                                        
                                            GET /wp-content/cache/autoptimize/css/autoptimize_72d2309f207561b24e84c4d6009a62d5.css HTTP/1.1 
Host: www.eicar.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: text/css,*/*;q=0.1
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/
Cookie: __wpdm_client=c11170dca089cc3d7eb6d01a7f1a1068; PHPSESSID=ieqprb25m18drt6ib4avksniff
Sec-Fetch-Dest: style
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: same-origin

                                         
                                         89.238.73.97
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Date: Wed, 28 Sep 2022 12:24:13 GMT
Server: Apache
Last-Modified: Thu, 22 Sep 2022 20:42:05 GMT
ETag: "136092-5e94a1823e9ae-gzip"
Accept-Ranges: bytes
Cache-Control: max-age=31536000 public
Expires: Mon, 18 Sep 2023 12:24:13 GMT
Vary: Accept-Encoding
Content-Encoding: gzip
Strict-Transport-Security: max-age=31536000; includeSubDomains
Keep-Alive: timeout=5, max=49
Connection: Keep-Alive
Transfer-Encoding: chunked


--- Additional Info ---
Magic:  ASCII text, with very long lines (42564)
Size:   139238
Md5:    1871f76cda9a0497342ee50c4309f1fa
Sha1:   5ffd6217a126bf1a36ab1d0f9aa847d9bd5a2006
Sha256: e11e29c123dbe37ee217f5dca29259a41bdde37628e05ef742e51a8cd8a336a0
                                        
                                            GET /wp-content/plugins/LayerSlider/assets/static/admin/img/blank.gif HTTP/1.1 
Host: www.eicar.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: image/avif,image/webp,*/*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/
Cookie: __wpdm_client=c11170dca089cc3d7eb6d01a7f1a1068; PHPSESSID=ieqprb25m18drt6ib4avksniff
Sec-Fetch-Dest: image
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: same-origin

                                         
                                         89.238.73.97
HTTP/1.1 200 OK
Content-Type: image/gif
                                        
Date: Wed, 28 Sep 2022 12:24:13 GMT
Server: Apache
Last-Modified: Thu, 22 Sep 2022 20:39:10 GMT
ETag: "2b-5e94a0db07f70"
Accept-Ranges: bytes
Content-Length: 43
Cache-Control: max-age=31536000 public
Expires: Thu, 28 Sep 2023 12:24:13 GMT
Strict-Transport-Security: max-age=31536000; includeSubDomains
Keep-Alive: timeout=5, max=49
Connection: Keep-Alive


--- Additional Info ---
Magic:  GIF image data, version 89a, 1 x 1\012- data
Size:   43
Md5:    325472601571f31e1bf00674c368d335
Sha1:   2daeaa8b5f19f0bc209d976c02bd6acb51b00b0a
Sha256: b1442e85b03bdcaf66dc58c7abb98745dd2687d86350be9a298a1d9382ac849b
                                        
                                            GET /wp-content/webp-express/webp-images/uploads/2022/06/eicar_info.jpg.webp HTTP/1.1 
Host: www.eicar.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: image/avif,image/webp,*/*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/
Cookie: __wpdm_client=c11170dca089cc3d7eb6d01a7f1a1068; PHPSESSID=ieqprb25m18drt6ib4avksniff
Sec-Fetch-Dest: image
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: same-origin

                                         
                                         89.238.73.97
HTTP/1.1 200 OK
Content-Type: image/webp
                                        
Date: Wed, 28 Sep 2022 12:24:13 GMT
Server: Apache
Last-Modified: Sun, 12 Jun 2022 06:12:43 GMT
ETag: "eb20-5e13a0f40203f"
Accept-Ranges: bytes
Content-Length: 60192
Cache-Control: max-age=31536000 public
Expires: Thu, 28 Sep 2023 12:24:13 GMT
Strict-Transport-Security: max-age=31536000; includeSubDomains
Keep-Alive: timeout=5, max=49
Connection: Keep-Alive


--- Additional Info ---
Magic:  RIFF (little-endian) data, Web/P image, VP8 encoding, 795x336, Scaling: [none]x[none], YUV color, decoders should clamp\012- data
Size:   60192
Md5:    bc0bde376b0b0a51aa1904d14e5d6d60
Sha1:   236825e10ebf4de71a9a954d31e9771bcb479b9e
Sha256: e17c7972df4c730ef7da3cf9fb1e7576e9ed14832daa69009f5052bde61494e6
                                        
                                            GET /wp-content/cache/autoptimize/js/autoptimize_60fbc671b7cecc6e9a5dfd63754659cf.js HTTP/1.1 
Host: www.eicar.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/
Cookie: __wpdm_client=c11170dca089cc3d7eb6d01a7f1a1068; PHPSESSID=ieqprb25m18drt6ib4avksniff
Sec-Fetch-Dest: script
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: same-origin

                                         
                                         89.238.73.97
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Wed, 28 Sep 2022 12:24:13 GMT
Server: Apache
Last-Modified: Thu, 22 Sep 2022 20:42:04 GMT
ETag: "ccf3a-5e94a180f38cf-gzip"
Accept-Ranges: bytes
Cache-Control: max-age=31536000, private
Expires: Mon, 18 Sep 2023 12:24:13 GMT
Vary: Accept-Encoding
Content-Encoding: gzip
Strict-Transport-Security: max-age=31536000; includeSubDomains
Keep-Alive: timeout=5, max=49
Connection: Keep-Alive
Transfer-Encoding: chunked


--- Additional Info ---
Magic:  ASCII text, with very long lines (28107)
Size:   243508
Md5:    7b7e706e4a30f36bd52746e33d29a2c3
Sha1:   2111bf7a6f5a81f8bb6c61e4f198d8dce454c8e6
Sha256: 6068069d778d41e53c5c9f34038e894e3ace6b4d260823b0c88a48b6abdd1002
                                        
                                            GET /wp-content/plugins/pwa/wp-includes/js/workbox-v6.5.3/workbox-window.prod.js HTTP/1.1 
Host: www.eicar.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/
Cookie: __wpdm_client=c11170dca089cc3d7eb6d01a7f1a1068; PHPSESSID=ieqprb25m18drt6ib4avksniff
Sec-Fetch-Dest: script
Sec-Fetch-Mode: cors
Sec-Fetch-Site: same-origin

                                         
                                         89.238.73.97
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Date: Wed, 28 Sep 2022 12:24:13 GMT
Server: Apache
Last-Modified: Thu, 09 Jun 2022 15:10:27 GMT
ETag: "d0b-5e10538ca9366-gzip"
Accept-Ranges: bytes
Cache-Control: max-age=31536000, private
Expires: Thu, 28 Sep 2023 12:24:13 GMT
Vary: Accept-Encoding
Content-Encoding: gzip
Strict-Transport-Security: max-age=31536000; includeSubDomains
Content-Length: 1330
Keep-Alive: timeout=5, max=48
Connection: Keep-Alive


--- Additional Info ---
Magic:  ASCII text, with very long lines (3290)
Size:   1330
Md5:    768da9ca641ac07f3a2b40bdea5d8795
Sha1:   739c89be9faa221a0f260bd2b3e9781a965b0366
Sha256: 422a3d19874d219ceaf8f2ca3df37b22e05ce90cf24041adbc7a64191e965c8b
                                        
                                            GET /wp-content/uploads/2022/05/eicar_BG_03.png HTTP/1.1 
Host: www.eicar.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: image/avif,image/webp,*/*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/wp-content/cache/autoptimize/css/autoptimize_72d2309f207561b24e84c4d6009a62d5.css
Cookie: __wpdm_client=c11170dca089cc3d7eb6d01a7f1a1068; PHPSESSID=ieqprb25m18drt6ib4avksniff
Sec-Fetch-Dest: image
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: same-origin

                                         
                                         89.238.73.97
HTTP/1.1 200 OK
Content-Type: image/webp
                                        
Date: Wed, 28 Sep 2022 12:24:13 GMT
Server: Apache
X-WebP-Convert-Log: Serving converted file
Vary: Accept
Last-Modified: Sat, 04 Jun 2022 06:45:35 GMT
Content-Length: 143618
Cache-Control: public
Expires: Thu, 28 Sep 2023 12:24:13 GMT
Strict-Transport-Security: max-age=31536000; includeSubDomains
Keep-Alive: timeout=5, max=47
Connection: Keep-Alive


--- Additional Info ---
Magic:  RIFF (little-endian) data, Web/P image\012- data
Size:   143618
Md5:    abdd31c095af58ceb5d058bca92fc49a
Sha1:   0da05d7088851525fbd36c3f14ad8cdd34e53270
Sha256: 1103da33a01f7ac3cf187a7710bf232ce800b5408889b90937eabecd8a6e37ca
                                        
                                            GET /wp-content/uploads/2022/05/eicar_10.jpg HTTP/1.1 
Host: www.eicar.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: image/avif,image/webp,*/*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/wp-content/cache/autoptimize/css/autoptimize_72d2309f207561b24e84c4d6009a62d5.css
Cookie: __wpdm_client=c11170dca089cc3d7eb6d01a7f1a1068; PHPSESSID=ieqprb25m18drt6ib4avksniff
Sec-Fetch-Dest: image
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: same-origin

                                         
                                         89.238.73.97
HTTP/1.1 200 OK
Content-Type: image/webp
                                        
Date: Wed, 28 Sep 2022 12:24:13 GMT
Server: Apache
X-WebP-Convert-Log: Serving converted file
Vary: Accept
Last-Modified: Sat, 04 Jun 2022 06:45:32 GMT
Content-Length: 74896
Cache-Control: public
Expires: Thu, 28 Sep 2023 12:24:13 GMT
Strict-Transport-Security: max-age=31536000; includeSubDomains
Keep-Alive: timeout=5, max=48
Connection: Keep-Alive


--- Additional Info ---
Magic:  RIFF (little-endian) data, Web/P image, VP8 encoding, 1920x1080, Scaling: [none]x[none], YUV color, decoders should clamp\012- data
Size:   74896
Md5:    0161b870e35cc6fc91a5a0ddc6e2a290
Sha1:   f16117eaaa2b9f1c1354d3d0701af8b65a5b6f51
Sha256: c3e96393ddce1c3ce1ea77fc610aac22fbc794f3279a605aa042f94af77ecac6
                                        
                                            GET /wp-content/uploads/2022/05/eicar_BG.jpg HTTP/1.1 
Host: www.eicar.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: image/avif,image/webp,*/*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/wp-content/cache/autoptimize/css/autoptimize_72d2309f207561b24e84c4d6009a62d5.css
Cookie: __wpdm_client=c11170dca089cc3d7eb6d01a7f1a1068; PHPSESSID=ieqprb25m18drt6ib4avksniff
Sec-Fetch-Dest: image
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: same-origin

                                         
                                         89.238.73.97
HTTP/1.1 200 OK
Content-Type: image/webp
                                        
Date: Wed, 28 Sep 2022 12:24:13 GMT
Server: Apache
X-WebP-Convert-Log: Serving converted file
Vary: Accept
Last-Modified: Sat, 04 Jun 2022 06:45:35 GMT
Content-Length: 105290
Cache-Control: public
Expires: Thu, 28 Sep 2023 12:24:13 GMT
Strict-Transport-Security: max-age=31536000; includeSubDomains
Keep-Alive: timeout=5, max=48
Connection: Keep-Alive


--- Additional Info ---
Magic:  RIFF (little-endian) data, Web/P image, VP8 encoding, 1920x1380, Scaling: [none]x[none], YUV color, decoders should clamp\012- data
Size:   105290
Md5:    81efbe90b28b8521d8ec31629b41e0a1
Sha1:   0126b9832b6760f695ae2dd90ea5b2dd7904d8f7
Sha256: 345a4d6d9d2581a07ae8c4e4e9e157c1a5fbbab8b3ba000a7ca5c1f124b23f6b
                                        
                                            GET /wp-content/themes/enfold/config-templatebuilder/avia-template-builder/assets/fonts/entypo-fontello.woff2 HTTP/1.1 
Host: www.eicar.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: application/font-woff2;q=1.0,application/font-woff;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: identity
Connection: keep-alive
Referer: https://www.eicar.com/
Cookie: __wpdm_client=c11170dca089cc3d7eb6d01a7f1a1068; PHPSESSID=ieqprb25m18drt6ib4avksniff
Sec-Fetch-Dest: font
Sec-Fetch-Mode: cors
Sec-Fetch-Site: same-origin

                                         
                                         89.238.73.97
HTTP/1.1 200 OK
Content-Type: font/woff2
                                        
Date: Wed, 28 Sep 2022 12:24:13 GMT
Server: Apache
Last-Modified: Thu, 08 Sep 2022 09:31:50 GMT
ETag: "9934-5e8271958dd45"
Accept-Ranges: bytes
Content-Length: 39220
Cache-Control: max-age=31536000 public
Expires: Fri, 28 Oct 2022 12:24:13 GMT
Strict-Transport-Security: max-age=31536000; includeSubDomains
Keep-Alive: timeout=5, max=48
Connection: Keep-Alive


--- Additional Info ---
Magic:  Web Open Font Format (Version 2), TrueType, length 39220, version 1.0\012- data
Size:   39220
Md5:    88bd94b6a31a73b5ee2b4a9799c7285e
Sha1:   59b220f616928d7baef57b681093c55c3f787abd
Sha256: 7f260ff280b2e54e84e6f9c2790da49cc9abadc457b77d1df4dea121a8c8ab6e
                                        
                                            GET /releases/v6.2.0/css/free.min.css?token=ed2a7f5fd4 HTTP/1.1 
Host: ka-f.fontawesome.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Referer: https://www.eicar.com/
Origin: https://www.eicar.com
Connection: keep-alive
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site

                                         
                                         172.64.202.28
HTTP/2 200 OK
content-type: text/css
                                        
date: Wed, 28 Sep 2022 12:24:14 GMT
access-control-allow-origin: *
access-control-allow-methods: GET
access-control-max-age: 3000
last-modified: Tue, 30 Aug 2022 16:04:58 GMT
etag: W/"0fb4e5b70c498af98f246511192b899d"
cache-control: max-age=31556926
access-control-allow-headers: fa-kit-token
vary: Accept-Encoding
x-cache: Hit from cloudfront
via: 1.1 0d0af2eea2f20e46e2262385b289cbae.cloudfront.net (CloudFront)
x-amz-cf-pop: TLV50-C2
x-amz-cf-id: 51r9vh80LDWFlzO1h7KEIvXtuOBtf2RC8i6RZpkczvoR00VzfFHEKQ==
age: 861304
cf-cache-status: HIT
report-to: {"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=JSO7eHS24cpKPfg7lYDiKo1vxKcNsYWbTTTY5VuZTqrefdw8dX5xF0bpL0C6DX3td8cy4QGdeI6sJ7AaX6ZRZD8B9hXmsvyrKThRtfEOc%2Fi8L9eJD2G2uTC99ubizR%2FSiKOZYyDXZw%3D%3D"}],"group":"cf-nel","max_age":604800}
nel: {"success_fraction":0,"report_to":"cf-nel","max_age":604800}
server: cloudflare
cf-ray: 751c74731eb875cf-LHR
content-encoding: br
alt-svc: h3=":443"; ma=86400, h3-29=":443"; ma=86400
X-Firefox-Spdy: h2


--- Additional Info ---
Magic:  ASCII text, with very long lines (65321)
Size:   177967
Md5:    75a3e7bbce0e9af3bc84f90d079606f4
Sha1:   438cad73c81a9e5e4dd6de9b1146831c20ed3a70
Sha256: 25a46e853721d60cd86452c861441ee9bb460501ecdda8238ca6f8949f285a72
                                        
                                            GET /releases/v6.2.0/css/free-v4-font-face.min.css?token=ed2a7f5fd4 HTTP/1.1 
Host: ka-f.fontawesome.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Referer: https://www.eicar.com/
Origin: https://www.eicar.com
Connection: keep-alive
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site

                                         
                                         172.64.202.28
HTTP/2 200 OK
content-type: text/css
                                        
date: Wed, 28 Sep 2022 12:24:14 GMT
access-control-allow-origin: *
access-control-allow-methods: GET
access-control-max-age: 3000
last-modified: Tue, 30 Aug 2022 16:04:58 GMT
etag: W/"a0adfe3c7bd1fa905b7f3b5ecea27889"
cache-control: max-age=31556926
access-control-allow-headers: fa-kit-token
vary: Accept-Encoding
x-cache: Hit from cloudfront
via: 1.1 329cb27be8d7871661ed5a94ecaacb28.cloudfront.net (CloudFront)
x-amz-cf-pop: LHR50-P1
x-amz-cf-id: xgscbKnTBint6_G1f_oH28mJDNGPfW8THGQ97hMGBwDhEIYOn9caJA==
age: 813662
cf-cache-status: HIT
report-to: {"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=LAbuFGXW%2Bx90WZua3Wi3M3K92cxVLD3hRUC1nEaCJwRkbyyjGLkF9d6GOSAAlo65UG%2F9jHattN8JEsBoJg7O9%2FqxF73rSQFg5FQyv0ksEH%2BB9boFbTD3XDH3e%2FDbldXeAuVKSVZDbQ%3D%3D"}],"group":"cf-nel","max_age":604800}
nel: {"success_fraction":0,"report_to":"cf-nel","max_age":604800}
server: cloudflare
cf-ray: 751c74732ed575cf-LHR
content-encoding: br
alt-svc: h3=":443"; ma=86400, h3-29=":443"; ma=86400
X-Firefox-Spdy: h2


--- Additional Info ---
Magic:  ASCII text, with very long lines (1560)
Size:   130383
Md5:    8d433cc3c2e7a55ae4f2c236d10fa6be
Sha1:   2be8aabc85f5a2343eecf7ff53f9d203a01c1e15
Sha256: 1feabca1e86ce7e11c702e578546e615e907d50cfad8dbec52e0f4d16fa128eb
                                        
                                            GET /wp-content/uploads/avia_fonts/type_fonts/opensans/opensans-regular.ttf HTTP/1.1 
Host: www.eicar.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: application/font-woff2;q=1.0,application/font-woff;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/wp-content/cache/autoptimize/css/autoptimize_72d2309f207561b24e84c4d6009a62d5.css
Cookie: __wpdm_client=c11170dca089cc3d7eb6d01a7f1a1068; PHPSESSID=ieqprb25m18drt6ib4avksniff
Sec-Fetch-Dest: font
Sec-Fetch-Mode: cors
Sec-Fetch-Site: same-origin

                                         
                                         89.238.73.97
HTTP/1.1 200 OK
Content-Type: font/ttf
                                        
Date: Wed, 28 Sep 2022 12:24:13 GMT
Server: Apache
Last-Modified: Wed, 22 Jun 2022 16:36:07 GMT
ETag: "1fb04-5e20bef131cc3"
Accept-Ranges: bytes
Content-Length: 129796
Cache-Control: max-age=31536000 public
Expires: Fri, 28 Oct 2022 12:24:13 GMT
Strict-Transport-Security: max-age=31536000; includeSubDomains
Keep-Alive: timeout=5, max=48
Connection: Keep-Alive


--- Additional Info ---
Magic:  TrueType Font data, 18 tables, 1st "GDEF", 22 names, Microsoft, language 0x409, Copyright 2020 The Open Sans Project Authors (https://github.com/googlefonts/opensans)Open SansR\012- data
Size:   129796
Md5:    58b1f440729d267697bddcddb994bce9
Sha1:   73b8e80d4ff1cf32806a12f296754819c17d4eff
Sha256: 4c4241959ddb26f3931a9bd611886cfb614250dfc64ff30bd3ee891bc15b6113
                                        
                                            GET /wp-content/webp-express/webp-images/uploads/2022/06/eicar_testfile.jpg.webp HTTP/1.1 
Host: www.eicar.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: image/avif,image/webp,*/*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/
Cookie: __wpdm_client=c11170dca089cc3d7eb6d01a7f1a1068; PHPSESSID=ieqprb25m18drt6ib4avksniff
Sec-Fetch-Dest: image
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: same-origin

                                         
                                         89.238.73.97
HTTP/1.1 200 OK
Content-Type: image/webp
                                        
Date: Wed, 28 Sep 2022 12:24:13 GMT
Server: Apache
Last-Modified: Sun, 12 Jun 2022 06:13:32 GMT
ETag: "a9f0-5e13a12265e91"
Accept-Ranges: bytes
Content-Length: 43504
Cache-Control: max-age=31536000 public
Expires: Thu, 28 Sep 2023 12:24:13 GMT
Strict-Transport-Security: max-age=31536000; includeSubDomains
Keep-Alive: timeout=5, max=45
Connection: Keep-Alive


--- Additional Info ---
Magic:  RIFF (little-endian) data, Web/P image, VP8 encoding, 795x336, Scaling: [none]x[none], YUV color, decoders should clamp\012- data
Size:   43504
Md5:    1c745ae503e24ed4dce0b1890b5ec610
Sha1:   9487700f34cb6307f4dd98800c4e1e36b0dcc44d
Sha256: fdd083f48e2d32aa1d2fb8c75aa69da6f7dafbeee7c086932800dec54ace81ff
                                        
                                            GET /wp-content/webp-express/webp-images/uploads/2022/06/eicar_team.jpg.webp HTTP/1.1 
Host: www.eicar.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: image/avif,image/webp,*/*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/
Cookie: __wpdm_client=c11170dca089cc3d7eb6d01a7f1a1068; PHPSESSID=ieqprb25m18drt6ib4avksniff
Sec-Fetch-Dest: image
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: same-origin

                                         
                                         89.238.73.97
HTTP/1.1 200 OK
Content-Type: image/webp
                                        
Date: Wed, 28 Sep 2022 12:24:13 GMT
Server: Apache
Last-Modified: Sun, 12 Jun 2022 06:13:07 GMT
ETag: "82e4-5e13a10b0a7ad"
Accept-Ranges: bytes
Content-Length: 33508
Cache-Control: max-age=31536000 public
Expires: Thu, 28 Sep 2023 12:24:13 GMT
Strict-Transport-Security: max-age=31536000; includeSubDomains
Keep-Alive: timeout=5, max=46
Connection: Keep-Alive


--- Additional Info ---
Magic:  RIFF (little-endian) data, Web/P image, VP8 encoding, 795x336, Scaling: [none]x[none], YUV color, decoders should clamp\012- data
Size:   33508
Md5:    81ac20454ba9c935682f5252a2646099
Sha1:   3deae85467eb44a06595c9468b03e620d34b0e59
Sha256: a56da2d5c4b5da390ada2b861a63ca8e4fa992b60edd1fee9defe897fe5a0e34
                                        
                                            GET /releases/v6.2.0/css/free-v4-shims.min.css?token=ed2a7f5fd4 HTTP/1.1 
Host: ka-f.fontawesome.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Referer: https://www.eicar.com/
Origin: https://www.eicar.com
Connection: keep-alive
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site

                                         
                                         172.64.202.28
HTTP/2 200 OK
content-type: text/css
                                        
date: Wed, 28 Sep 2022 12:24:14 GMT
access-control-allow-origin: *
access-control-allow-methods: GET
access-control-max-age: 3000
last-modified: Tue, 30 Aug 2022 16:04:58 GMT
etag: W/"58dea8f45bf2685132179a837507637a"
cache-control: max-age=31556926
access-control-allow-headers: fa-kit-token
vary: Accept-Encoding
x-cache: Hit from cloudfront
via: 1.1 17a77a72dc1e9981253a822e540e37c2.cloudfront.net (CloudFront)
x-amz-cf-pop: LHR50-P1
x-amz-cf-id: -Z_-N_L_ShtQQ38lHpsMELOGRhyErmw6csJcdHu9gqsSzsUC-Mcruw==
age: 813662
cf-cache-status: HIT
report-to: {"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=B4lK0RrhhH8KeQRlk8zk6Y7NhvCIGMy%2ByalL54WDDTc6chDAd7TqhuVJyeWKNiXbMiFfoq1RVq4bI0xFBmn%2Bz2gKlJlV45N%2FmBhFRLYwifkHzX5ZIUeym95v53KiTOBdtygieH%2FhcQ%3D%3D"}],"group":"cf-nel","max_age":604800}
nel: {"success_fraction":0,"report_to":"cf-nel","max_age":604800}
server: cloudflare
cf-ray: 751c74733edc75cf-LHR
content-encoding: br
alt-svc: h3=":443"; ma=86400, h3-29=":443"; ma=86400
X-Firefox-Spdy: h2


--- Additional Info ---
Magic:  ASCII text, with very long lines (27377)
Size:   134116
Md5:    01ac1bd4337160cc0b6c14d76e75589b
Sha1:   7f6169b96b7a4ce6d348fd9b5cfbc7ede5390295
Sha256: 4270d2a4e7fab4a94457cf9eae39570515ddf9a601961a10ddc9c4c239403371
                                        
                                            GET /badges/js/profile.js HTTP/1.1 
Host: platform.linkedin.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/
Sec-Fetch-Dest: script
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: cross-site

                                         
                                         23.36.76.121
HTTP/2 200 OK
content-type: application/javascript; charset=utf-8
                                        
server: Play
cache-control: public, max-age=3600
last-modified: Fri, 01 Feb 1980 00:00:00 GMT
content-length: 1074
content-encoding: gzip
x-fs-txn-id: 2b8b851010f0
x-fs-uuid: 16e1e5b1af54131670d03002a12b0000
x-li-fabric: prod-lva1
x-li-pop: prod-efr5
x-li-proto: http/1.1
x-li-uuid: FuHlsa9UExZw0DACoSsAAA==
x-edgeconnect-midmile-rtt: 0, 0, 4, 0, 0
x-edgeconnect-origin-mex-latency: 654, 665, 167, 183, 149
unused62: 8096267
date: Wed, 28 Sep 2022 12:24:14 GMT
vary: Accept-Encoding
x-cdn-client-ip-version: IPV4
x-cdn: AKAM
X-Firefox-Spdy: h2


--- Additional Info ---
Magic:  ASCII text, with very long lines (521)
Size:   1074
Md5:    6b7c8f103577c259e34263d0b7d41ef0
Sha1:   b808bd4bfb2fe91fa44040901839dd90e1a478f5
Sha256: 7f5011da3af367b60ca3c628933eab1117fa58bb28990f47e48f403145001103
                                        
                                            GET /wp-content/uploads/2022/05/eicar_icon_16x16.png HTTP/1.1 
Host: www.eicar.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: image/avif,image/webp,*/*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/
Cookie: __wpdm_client=c11170dca089cc3d7eb6d01a7f1a1068; PHPSESSID=ieqprb25m18drt6ib4avksniff
Sec-Fetch-Dest: image
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: same-origin

                                         
                                         89.238.73.97
HTTP/1.1 200 OK
Content-Type: image/webp
                                        
Date: Wed, 28 Sep 2022 12:24:14 GMT
Server: Apache
X-WebP-Convert-Log: Serving converted file
Vary: Accept
Last-Modified: Sat, 04 Jun 2022 06:44:01 GMT
Content-Length: 472
Cache-Control: public
Expires: Thu, 28 Sep 2023 12:24:14 GMT
Strict-Transport-Security: max-age=31536000; includeSubDomains
Keep-Alive: timeout=5, max=44
Connection: Keep-Alive


--- Additional Info ---
Magic:  RIFF (little-endian) data, Web/P image\012- data
Size:   472
Md5:    b4b3637265dab333aa307582be8f3064
Sha1:   1ecc68505891a4f2dc118d2bec6f0785bc6a3bf3
Sha256: 1c11fc57caf5577894a9c49c1c42a70778b3fc24d5ed74589c869aec1ff73b24
                                        
                                            GET /wp-content/plugins/LayerSlider/assets/static/layerslider/skins/v6/skin.css HTTP/1.1 
Host: www.eicar.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: text/css,*/*;q=0.1
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/
Cookie: __wpdm_client=c11170dca089cc3d7eb6d01a7f1a1068; PHPSESSID=ieqprb25m18drt6ib4avksniff
Sec-Fetch-Dest: style
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: same-origin

                                         
                                         89.238.73.97
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Date: Wed, 28 Sep 2022 12:24:14 GMT
Server: Apache
Last-Modified: Thu, 22 Sep 2022 20:39:09 GMT
ETag: "164a-5e94a0daf1810-gzip"
Accept-Ranges: bytes
Cache-Control: max-age=31536000 public
Expires: Fri, 28 Oct 2022 12:24:14 GMT
Vary: Accept-Encoding
Content-Encoding: gzip
Strict-Transport-Security: max-age=31536000; includeSubDomains
Content-Length: 1037
Keep-Alive: timeout=5, max=45
Connection: Keep-Alive


--- Additional Info ---
Magic:  ASCII text
Size:   1037
Md5:    ca8ac6ec15ec65501ec6b5bdba9ce518
Sha1:   38de2fabe80a62144fe50732a9c057a3e4684333
Sha256: fe2a1506f09dd844d2856e8fd354d1052101c7f75ac1026221f3c6559856243b
                                        
                                            GET /releases/v6.2.0/webfonts/free-fa-solid-900.woff2 HTTP/1.1 
Host: ka-f.fontawesome.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: application/font-woff2;q=1.0,application/font-woff;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: identity
Origin: https://www.eicar.com
Connection: keep-alive
Referer: https://www.eicar.com/
Sec-Fetch-Dest: font
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site
TE: trailers

                                         
                                         172.64.202.28
HTTP/2 200 OK
content-type: font/woff2
                                        
date: Wed, 28 Sep 2022 12:24:15 GMT
content-length: 150456
access-control-allow-origin: *
access-control-allow-methods: GET
access-control-max-age: 3000
last-modified: Tue, 30 Aug 2022 16:15:00 GMT
etag: "822fa3f2f51f169c970f713b88158737"
cache-control: max-age=31556926
access-control-allow-headers: fa-kit-token
x-cache: Hit from cloudfront
via: 1.1 ee8862e43d7837ef5478becfe2eb7116.cloudfront.net (CloudFront)
x-amz-cf-pop: LHR50-P1
x-amz-cf-id: yxOtKe447qjmqTBd1nPUhVmp0bGVCVNePvhGEwdJp9gn7DhpaxCd-g==
age: 813662
cf-cache-status: HIT
accept-ranges: bytes
report-to: {"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=qMenBITjC4a7r7PbK4ABLfj3UfVfFd%2FKGLIuxZN722NzmX9NGVMFV%2FA7fiCiAbseW99HOQBEg1SMQ9ZCbDN%2F51F5RHn%2B9%2F2usP5Av03o%2Bgas5lRbBctult95tU2oiIAyzBts1KkYJQ%3D%3D"}],"group":"cf-nel","max_age":604800}
nel: {"success_fraction":0,"report_to":"cf-nel","max_age":604800}
vary: Accept-Encoding
server: cloudflare
cf-ray: 751c7476ac5575cf-LHR
alt-svc: h3=":443"; ma=86400, h3-29=":443"; ma=86400
X-Firefox-Spdy: h2


--- Additional Info ---
Magic:  Web Open Font Format (Version 2), TrueType, length 150456, version 770.256\012- data
Size:   150456
Md5:    822fa3f2f51f169c970f713b88158737
Sha1:   74b5ddde927a0f84883fed55a65ffbb6ada11761
Sha256: ad28ece0bf48b1488c82aaf700201d7f6b56a62e11b5b6a0a12481780c8a3417
                                        
                                            GET /wp-content/uploads/2022/05/Pattern_03.png HTTP/1.1 
Host: www.eicar.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: image/avif,image/webp,*/*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/
Cookie: __wpdm_client=c11170dca089cc3d7eb6d01a7f1a1068; PHPSESSID=ieqprb25m18drt6ib4avksniff
Sec-Fetch-Dest: image
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: same-origin

                                         
                                         89.238.73.97
HTTP/1.1 200 OK
Content-Type: image/webp
                                        
Date: Wed, 28 Sep 2022 12:24:14 GMT
Server: Apache
X-WebP-Convert-Log: Serving converted file
Vary: Accept
Last-Modified: Sat, 04 Jun 2022 06:44:11 GMT
Content-Length: 6034
Cache-Control: public
Expires: Thu, 28 Sep 2023 12:24:14 GMT
Strict-Transport-Security: max-age=31536000; includeSubDomains
Keep-Alive: timeout=5, max=44
Connection: Keep-Alive


--- Additional Info ---
Magic:  RIFF (little-endian) data, Web/P image\012- data
Size:   6034
Md5:    9a5bc19997d12c33dbda456174458cb6
Sha1:   4c4a3fbc29b9d2714f3e50f4b725a7652a96f864
Sha256: 26195de186316e28f5ae2b1e40b147465a284c92a78f1f9200f5e3c1f8b19634
                                        
                                            POST /gts1c3 HTTP/1.1 
Host: ocsp.pki.goog
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Content-Type: application/ocsp-request
Content-Length: 84
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache

                                         
                                         142.250.74.3
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Date: Wed, 28 Sep 2022 12:24:15 GMT
Cache-Control: public, max-age=14400
Server: ocsp_responder
Content-Length: 472
X-XSS-Protection: 0
X-Frame-Options: SAMEORIGIN

                                        
                                            POST /gts1c3 HTTP/1.1 
Host: ocsp.pki.goog
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Content-Type: application/ocsp-request
Content-Length: 84
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache

                                         
                                         142.250.74.3
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Date: Wed, 28 Sep 2022 12:24:15 GMT
Cache-Control: public, max-age=14400
Server: ocsp_responder
Content-Length: 472
X-XSS-Protection: 0
X-Frame-Options: SAMEORIGIN

                                        
                                            POST /gts1c3 HTTP/1.1 
Host: ocsp.pki.goog
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Content-Type: application/ocsp-request
Content-Length: 84
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache

                                         
                                         142.250.74.3
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Date: Wed, 28 Sep 2022 12:24:15 GMT
Cache-Control: public, max-age=14400
Server: ocsp_responder
Content-Length: 472
X-XSS-Protection: 0
X-Frame-Options: SAMEORIGIN

                                        
                                            POST /gts1c3 HTTP/1.1 
Host: ocsp.pki.goog
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Content-Type: application/ocsp-request
Content-Length: 84
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache

                                         
                                         142.250.74.3
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Date: Wed, 28 Sep 2022 12:24:15 GMT
Cache-Control: public, max-age=14400
Server: ocsp_responder
Content-Length: 472
X-XSS-Protection: 0
X-Frame-Options: SAMEORIGIN

                                        
                                            GET /wp-content/plugins/LayerSlider/assets/static/layerslider/img/icon-muted-white.png HTTP/1.1 
Host: www.eicar.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: image/avif,image/webp,*/*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/wp-content/cache/autoptimize/css/autoptimize_72d2309f207561b24e84c4d6009a62d5.css
Cookie: __wpdm_client=c11170dca089cc3d7eb6d01a7f1a1068; PHPSESSID=ieqprb25m18drt6ib4avksniff
Sec-Fetch-Dest: image
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: same-origin

                                         
                                         89.238.73.97
HTTP/1.1 200 OK
Content-Type: text/html; charset=UTF-8
                                        
Date: Wed, 28 Sep 2022 12:24:14 GMT
Server: Apache
X-WebP-Express-Error: Sanity check failed for destination path: String expected
Vary: Accept,Accept-Encoding
Cache-Control: public
Expires: Fri, 28 Oct 2022 12:24:14 GMT
Content-Encoding: gzip
Strict-Transport-Security: max-age=31536000; includeSubDomains
Content-Length: 74
Keep-Alive: timeout=5, max=47
Connection: Keep-Alive


--- Additional Info ---
Magic:  ASCII text, with no line terminators
Size:   74
Md5:    11ad5ef03ff1d4b639ad75b9b8bc85fe
Sha1:   4ab362a15e06871887cb9fdbe185a24b2345db9e
Sha256: ca913172e04fe39192d6c515eb77edec2f4dcb18b0823a71e4ed5ec7bd50bfc7
                                        
                                            GET /wp-content/plugins/LayerSlider/assets/static/layerslider/img/icon-unmuted-white.png HTTP/1.1 
Host: www.eicar.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: image/avif,image/webp,*/*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/wp-content/cache/autoptimize/css/autoptimize_72d2309f207561b24e84c4d6009a62d5.css
Cookie: __wpdm_client=c11170dca089cc3d7eb6d01a7f1a1068; PHPSESSID=ieqprb25m18drt6ib4avksniff
Sec-Fetch-Dest: image
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: same-origin

                                         
                                         89.238.73.97
HTTP/1.1 200 OK
Content-Type: text/html; charset=UTF-8
                                        
Date: Wed, 28 Sep 2022 12:24:14 GMT
Server: Apache
X-WebP-Express-Error: Sanity check failed for destination path: String expected
Vary: Accept,Accept-Encoding
Cache-Control: public
Expires: Fri, 28 Oct 2022 12:24:14 GMT
Content-Encoding: gzip
Strict-Transport-Security: max-age=31536000; includeSubDomains
Content-Length: 74
Keep-Alive: timeout=5, max=48
Connection: Keep-Alive


--- Additional Info ---
Magic:  ASCII text, with no line terminators
Size:   74
Md5:    11ad5ef03ff1d4b639ad75b9b8bc85fe
Sha1:   4ab362a15e06871887cb9fdbe185a24b2345db9e
Sha256: ca913172e04fe39192d6c515eb77edec2f4dcb18b0823a71e4ed5ec7bd50bfc7
                                        
                                            POST /gts1c3 HTTP/1.1 
Host: ocsp.pki.goog
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Content-Type: application/ocsp-request
Content-Length: 84
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache

                                         
                                         142.250.74.3
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Date: Wed, 28 Sep 2022 12:24:15 GMT
Cache-Control: public, max-age=14400
Server: ocsp_responder
Content-Length: 472
X-XSS-Protection: 0
X-Frame-Options: SAMEORIGIN

                                        
                                            GET /wp-content/plugins/LayerSlider/assets/static/layerslider/skins/v6/nothumb.png HTTP/1.1 
Host: www.eicar.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: image/avif,image/webp,*/*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/
Cookie: __wpdm_client=c11170dca089cc3d7eb6d01a7f1a1068; PHPSESSID=ieqprb25m18drt6ib4avksniff
Sec-Fetch-Dest: image
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: same-origin

                                         
                                         89.238.73.97
HTTP/1.1 200 OK
Content-Type: text/html; charset=UTF-8
                                        
Date: Wed, 28 Sep 2022 12:24:14 GMT
Server: Apache
X-WebP-Express-Error: Sanity check failed for destination path: String expected
Vary: Accept,Accept-Encoding
Cache-Control: public
Expires: Fri, 28 Oct 2022 12:24:14 GMT
Content-Encoding: gzip
Strict-Transport-Security: max-age=31536000; includeSubDomains
Content-Length: 74
Keep-Alive: timeout=5, max=43
Connection: Keep-Alive


--- Additional Info ---
Magic:  ASCII text, with no line terminators
Size:   74
Md5:    11ad5ef03ff1d4b639ad75b9b8bc85fe
Sha1:   4ab362a15e06871887cb9fdbe185a24b2345db9e
Sha256: ca913172e04fe39192d6c515eb77edec2f4dcb18b0823a71e4ed5ec7bd50bfc7
                                        
                                            POST /gts1c3 HTTP/1.1 
Host: ocsp.pki.goog
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Content-Type: application/ocsp-request
Content-Length: 83
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache

                                         
                                         142.250.74.3
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Date: Wed, 28 Sep 2022 12:24:15 GMT
Cache-Control: public, max-age=14400
Server: ocsp_responder
Content-Length: 471
X-XSS-Protection: 0
X-Frame-Options: SAMEORIGIN

                                        
                                            GET /vi/7Zwu1N8h3s8/hqdefault.jpg HTTP/1.1 
Host: img.youtube.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: image/avif,image/webp,*/*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/
Sec-Fetch-Dest: image
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: cross-site

                                         
                                         216.58.207.238
HTTP/2 200 OK
content-type: image/jpeg
                                        
accept-ranges: bytes
vary: Origin
cross-origin-resource-policy: cross-origin
cross-origin-opener-policy-report-only: same-origin; report-to="youtube"
report-to: {"group":"youtube","max_age":2592000,"endpoints":[{"url":"https://csp.withgoogle.com/csp/report-to/youtube"}]}
timing-allow-origin: *
content-length: 30281
x-content-type-options: nosniff
server: sffe
x-xss-protection: 0
date: Wed, 28 Sep 2022 12:24:15 GMT
expires: Wed, 28 Sep 2022 14:24:15 GMT
cache-control: public, max-age=7200
etag: "1657184214"
age: 0
alt-svc: h3=":443"; ma=2592000,h3-29=":443"; ma=2592000,h3-Q050=":443"; ma=2592000,h3-Q046=":443"; ma=2592000,h3-Q043=":443"; ma=2592000,quic=":443"; ma=2592000; v="46,43"
X-Firefox-Spdy: h2


--- Additional Info ---
Magic:  JPEG image data, JFIF standard 1.01, aspect ratio, density 1x1, segment length 16, baseline, precision 8, 480x360, components 3\012- data
Size:   30281
Md5:    4d9636b0f7e3b3da89f3ce70e909b24d
Sha1:   1e58c7d4352c63ce1e2d0a90f39a89e04cd2eb4e
Sha256: 4043bff9ee6f689c07770ee4d606e001d63cdf86cc014d46723c8bb9719da1ae
                                        
                                            GET /vi/7Zwu1N8h3s8/default.jpg HTTP/1.1 
Host: img.youtube.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: image/avif,image/webp,*/*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/
Sec-Fetch-Dest: image
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: cross-site

                                         
                                         216.58.207.238
HTTP/2 200 OK
content-type: image/jpeg
                                        
accept-ranges: bytes
vary: Origin
cross-origin-resource-policy: cross-origin
cross-origin-opener-policy-report-only: same-origin; report-to="youtube"
report-to: {"group":"youtube","max_age":2592000,"endpoints":[{"url":"https://csp.withgoogle.com/csp/report-to/youtube"}]}
timing-allow-origin: *
content-length: 3719
x-content-type-options: nosniff
server: sffe
x-xss-protection: 0
date: Wed, 28 Sep 2022 12:24:15 GMT
expires: Wed, 28 Sep 2022 14:24:15 GMT
cache-control: public, max-age=7200
etag: "1657184214"
age: 0
alt-svc: h3=":443"; ma=2592000,h3-29=":443"; ma=2592000,h3-Q050=":443"; ma=2592000,h3-Q046=":443"; ma=2592000,h3-Q043=":443"; ma=2592000,quic=":443"; ma=2592000; v="46,43"
X-Firefox-Spdy: h2


--- Additional Info ---
Magic:  JPEG image data, JFIF standard 1.01, aspect ratio, density 1x1, segment length 16, baseline, precision 8, 120x90, components 3\012- data
Size:   3719
Md5:    0ff4005a8a7a2c4717d3f52abc8ef9e4
Sha1:   5aeda448a7e412f9a5864368161721885901a33c
Sha256: 323ca7e7c2bb24df0781504ad722668f71562a390ee29ca5c62c01fc408f8ac0
                                        
                                            GET /vi/7Zwu1N8h3s8/maxresdefault.jpg HTTP/1.1 
Host: img.youtube.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: image/avif,image/webp,*/*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/
Sec-Fetch-Dest: image
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: cross-site

                                         
                                         216.58.207.238
HTTP/2 200 OK
content-type: image/jpeg
                                        
accept-ranges: bytes
vary: Origin
cross-origin-resource-policy: cross-origin
cross-origin-opener-policy-report-only: same-origin; report-to="youtube"
report-to: {"group":"youtube","max_age":2592000,"endpoints":[{"url":"https://csp.withgoogle.com/csp/report-to/youtube"}]}
timing-allow-origin: *
content-length: 131307
x-content-type-options: nosniff
server: sffe
x-xss-protection: 0
date: Wed, 28 Sep 2022 12:24:15 GMT
expires: Wed, 28 Sep 2022 14:24:15 GMT
cache-control: public, max-age=7200
etag: "1657184214"
age: 0
alt-svc: h3=":443"; ma=2592000,h3-29=":443"; ma=2592000,h3-Q050=":443"; ma=2592000,h3-Q046=":443"; ma=2592000,h3-Q043=":443"; ma=2592000,quic=":443"; ma=2592000; v="46,43"
X-Firefox-Spdy: h2


--- Additional Info ---
Magic:  JPEG image data, JFIF standard 1.01, aspect ratio, density 1x1, segment length 16, baseline, precision 8, 1280x720, components 3\012- data
Size:   131307
Md5:    10473143efacdf574918ad4034a41a5c
Sha1:   88fb0b7bc130e3626a8a900c8c2e15ee80e96fad
Sha256: 378627b65a459c333c3f48735118b13e5ec36d6325121bae227a449d92f88dd8
                                        
                                            GET /vi/7Zwu1N8h3s8/mqdefault.jpg HTTP/1.1 
Host: img.youtube.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: image/avif,image/webp,*/*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/
Sec-Fetch-Dest: image
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: cross-site

                                         
                                         216.58.207.238
HTTP/2 200 OK
content-type: image/jpeg
                                        
accept-ranges: bytes
vary: Origin
cross-origin-resource-policy: cross-origin
cross-origin-opener-policy-report-only: same-origin; report-to="youtube"
report-to: {"group":"youtube","max_age":2592000,"endpoints":[{"url":"https://csp.withgoogle.com/csp/report-to/youtube"}]}
timing-allow-origin: *
content-length: 15333
x-content-type-options: nosniff
server: sffe
x-xss-protection: 0
date: Wed, 28 Sep 2022 12:24:15 GMT
expires: Wed, 28 Sep 2022 14:24:15 GMT
cache-control: public, max-age=7200
etag: "1657184214"
age: 0
alt-svc: h3=":443"; ma=2592000,h3-29=":443"; ma=2592000,h3-Q050=":443"; ma=2592000,h3-Q046=":443"; ma=2592000,h3-Q043=":443"; ma=2592000,quic=":443"; ma=2592000; v="46,43"
X-Firefox-Spdy: h2


--- Additional Info ---
Magic:  JPEG image data, JFIF standard 1.01, aspect ratio, density 1x1, segment length 16, baseline, precision 8, 320x180, components 3\012- data
Size:   15333
Md5:    aad97bd09827088f9166fb67ce7e0486
Sha1:   ccbb0d8a7fe829a24516d6344cf0f284dc74407c
Sha256: e8d7918e4cce75f58c411e2983a54eecaebaa55a892a91b723d845c9e826a6fe
                                        
                                            GET /vi/7Zwu1N8h3s8/sddefault.jpg HTTP/1.1 
Host: img.youtube.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: image/avif,image/webp,*/*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/
Sec-Fetch-Dest: image
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: cross-site

                                         
                                         216.58.207.238
HTTP/2 200 OK
content-type: image/jpeg
                                        
accept-ranges: bytes
vary: Origin
cross-origin-resource-policy: cross-origin
cross-origin-opener-policy-report-only: same-origin; report-to="youtube"
report-to: {"group":"youtube","max_age":2592000,"endpoints":[{"url":"https://csp.withgoogle.com/csp/report-to/youtube"}]}
timing-allow-origin: *
content-length: 49332
x-content-type-options: nosniff
server: sffe
x-xss-protection: 0
date: Wed, 28 Sep 2022 12:24:15 GMT
expires: Wed, 28 Sep 2022 14:24:15 GMT
cache-control: public, max-age=7200
etag: "1657184214"
age: 0
alt-svc: h3=":443"; ma=2592000,h3-29=":443"; ma=2592000,h3-Q050=":443"; ma=2592000,h3-Q046=":443"; ma=2592000,h3-Q043=":443"; ma=2592000,quic=":443"; ma=2592000; v="46,43"
X-Firefox-Spdy: h2


--- Additional Info ---
Magic:  JPEG image data, JFIF standard 1.01, aspect ratio, density 1x1, segment length 16, baseline, precision 8, 640x480, components 3\012- data
Size:   49332
Md5:    242cb3b566649cce175eff70012ee5ba
Sha1:   fbf94518fef40cb01cff8da00791862d72c44cda
Sha256: 4a1abf57bc58e2a959caf7d0b42c6f0160234e50e591ff7ba29f084d94512c25
                                        
                                            GET /wp-content/uploads/2022/05/Pattern_02-e1656228549870-1500x804.png HTTP/1.1 
Host: www.eicar.com
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: image/avif,image/webp,*/*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Referer: https://www.eicar.com/
Cookie: __wpdm_client=c11170dca089cc3d7eb6d01a7f1a1068; PHPSESSID=ieqprb25m18drt6ib4avksniff
Sec-Fetch-Dest: image
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: same-origin

                                         
                                         89.238.73.97
HTTP/1.1 200 OK
Content-Type: image/webp
                                        
Date: Wed, 28 Sep 2022 12:24:14 GMT
Server: Apache
X-WebP-Convert-Log: Serving converted file
Vary: Accept
Last-Modified: Sun, 26 Jun 2022 07:29:20 GMT
Content-Length: 79230
Cache-Control: public
Expires: Thu, 28 Sep 2023 12:24:14 GMT
Strict-Transport-Security: max-age=31536000; includeSubDomains
Keep-Alive: timeout=5, max=47
Connection: Keep-Alive


--- Additional Info ---
Magic:  RIFF (little-endian) data, Web/P image\012- data
Size:   79230
Md5:    97985017b96f2ebc4d98ed95239eaaed
Sha1:   84616776925675fa59af274e653849fb1ab19e4f
Sha256: 56f0939e68c5891460b78e3e776dd2115a6cf6c7e5f4732a362c1f59c28ee492
                                        
                                            POST /gts1c3 HTTP/1.1 
Host: ocsp.pki.goog
                                        
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:96.0) Gecko/20100101 Firefox/96.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Content-Type: application/ocsp-request
Content-Length: 84
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache

                                         
                                         142.250.74.3
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Date: Wed, 28 Sep 2022 12:24:15 GMT
Cache-Control: public, max-age=14400
Server: ocsp_responder
Content-Length: 472
X-XSS-Protection: 0
X-Frame-Options: SAMEORIGIN


--- Additional Info ---
Magic:  data
Size:   472
Md5:    be52dbe2d47697a7f007d69c486b77b4