Overview

URL mindfuldog.es/
IP185.209.60.23
ASNEuskaltel S.A.
Location Spain
Report completed2022-09-28 02:25:50 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
Scan Date Severity Indicator Comment
2022-09-28 2 mindfuldog.es/ Phishing
2022-09-28 2 mindfuldog.es/wp-content/plugins/photo-gallery/css/bwg_frontend.css?ver=1.4.5 Phishing
2022-09-28 2 mindfuldog.es/wp-content/plugins/photo-gallery/css/jquery.mCustomScrollbar. (...) Phishing
2022-09-28 2 mindfuldog.es/wp-includes/js/wp-emoji-release.min.js?ver=4.9.21 Phishing
2022-09-28 2 mindfuldog.es/wp-content/themes/uncode-child/style.css?ver=592795229 Phishing
2022-09-28 2 mindfuldog.es/wp-content/plugins/revslider/public/assets/css/settings.css?v (...) Phishing
2022-09-28 2 mindfuldog.es/wp-content/plugins/addthis/frontend/build/addthis_wordpress_p (...) Phishing
2022-09-28 2 mindfuldog.es/wp-content/plugins/jquery-validation-for-contact-form-7/inclu (...) Phishing
2022-09-28 2 mindfuldog.es/wp-content/themes/uncode/library/css/uncode-icons.css?ver=178 (...) Phishing
2022-09-28 2 mindfuldog.es/wp-content/themes/uncode/library/css/style.css?ver=592795229 Phishing
2022-09-28 2 mindfuldog.es/wp-includes/js/jquery/jquery-migrate.min.js?ver=1.4.1 Phishing
2022-09-28 2 mindfuldog.es/wp-content/themes/uncode/library/css/woocommerce.css?ver=514051736 Phishing
2022-09-28 2 mindfuldog.es/wp-content/plugins/LayerSlider/static/layerslider/js/layersli (...) Phishing
2022-09-28 2 mindfuldog.es/wp-content/plugins/LayerSlider/static/layerslider/js/layersli (...) Phishing
2022-09-28 2 mindfuldog.es/wp-content/plugins/photo-gallery/js/jquery.mobile.js?ver=1.4.5 Phishing
2022-09-28 2 mindfuldog.es/wp-content/plugins/photo-gallery/js/jquery.mCustomScrollbar.c (...) Phishing
2022-09-28 2 mindfuldog.es/wp-content/plugins/photo-gallery/js/jquery.fullscreen-0.4.1.j (...) Phishing
2022-09-28 2 mindfuldog.es/wp-content/plugins/LayerSlider/static/layerslider/js/greensoc (...) Phishing
2022-09-28 2 mindfuldog.es/wp-includes/js/jquery/jquery.js?ver=1.12.4 Phishing
2022-09-28 2 mindfuldog.es/wp-content/plugins/revslider/public/assets/js/jquery.themepun (...) Phishing
2022-09-28 2 mindfuldog.es/wp-content/plugins/woocommerce/assets/js/frontend/add-to-cart (...) Phishing
2022-09-28 2 mindfuldog.es/wp-content/plugins/wwm-social-share-on-image-hover/js/wwm_cus (...) Phishing
2022-09-28 2 mindfuldog.es/wp-content/plugins/uncode-js_composer/assets/js/vendors/wooco (...) Phishing
2022-09-28 2 mindfuldog.es/wp-includes/js/mediaelement/mediaelement-migrate.min.js?ver=4.9.21 Phishing
2022-09-28 2 mindfuldog.es/wp-content/themes/uncode/library/js/min/ai-uncode.min.js Phishing
2022-09-28 2 mindfuldog.es/wp-content/plugins/wonderplugin-lightbox/engine/wonderpluginl (...) Phishing
2022-09-28 2 mindfuldog.es/wp-includes/js/underscore.min.js?ver=1.8.3 Phishing
2022-09-28 2 mindfuldog.es/wp-content/plugins/contact-form-7/includes/js/scripts.js?ver=5.0.2 Phishing
2022-09-28 2 mindfuldog.es/wp-content/plugins/uk-cookie-consent/assets/js/uk-cookie-cons (...) Phishing
2022-09-28 2 mindfuldog.es/wp-content/plugins/woocommerce/assets/js/jquery-blockui/jquer (...) Phishing
2022-09-28 2 mindfuldog.es/wp-content/plugins/woocommerce/assets/js/js-cookie/js.cookie. (...) Phishing
2022-09-28 2 mindfuldog.es/wp-content/plugins/woocommerce/assets/js/frontend/woocommerce (...) Phishing
2022-09-28 2 mindfuldog.es/wp-content/themes/uncode/library/js/init.js?ver=178556683 Phishing
2022-09-28 2 mindfuldog.es/wp-content/plugins/woocommerce/assets/js/frontend/cart-fragme (...) Phishing
2022-09-28 2 mindfuldog.es/wp-content/plugins/gallery-by-supsystic/src/GridGallery/Color (...) Phishing
2022-09-28 2 mindfuldog.es/wp-includes/js/mediaelement/wp-mediaelement.min.js?ver=4.9.21 Phishing
2022-09-28 2 mindfuldog.es/wp-content/plugins/jquery-validation-for-contact-form-7/inclu (...) Phishing
2022-09-28 2 mindfuldog.es/wp-content/plugins/jquery-validation-for-contact-form-7/inclu (...) Phishing
2022-09-28 2 mindfuldog.es/wp-content/themes/uncode/core/inc/uncode-ajax.php Phishing
2022-09-28 2 mindfuldog.es/wp-content/themes/uncode/library/js/plugins.js?ver=178556683 Phishing
2022-09-28 2 mindfuldog.es/wp-content/themes/uncode/core/inc/uncode-ajax.php Phishing
2022-09-28 2 mindfuldog.es/wp-content/themes/uncode/library/fonts/uncode-icons.woff2 Phishing
2022-09-28 2 mindfuldog.es/wp-content/themes/uncode/core/inc/uncode-ajax.php Phishing
2022-09-28 2 mindfuldog.es/wp-content/plugins/wonderplugin-lightbox/engine/froogaloop2.min.js Phishing
2022-09-28 2 mindfuldog.es/wp-content/themes/uncode/core/inc/uncode-ajax.php Phishing
2022-09-28 2 mindfuldog.es/wp-content/themes/uncode/core/inc/uncode-ajax.php Phishing
2022-09-28 2 mindfuldog.es/wp-content/themes/uncode/core/inc/uncode-ajax.php Phishing
2022-09-28 2 mindfuldog.es/wp-admin/admin-ajax.php Phishing
2022-09-28 2 mindfuldog.es/wp-includes/js/mediaelement/mediaelement-and-player.min.js?ve (...) Phishing
2022-09-28 2 mindfuldog.es/wp-content/themes/uncode/library/css/style-custom.css?ver=178 (...) Phishing
mnemonic secure dns  No alerts detected
Quad9 DNS  No alerts detected


Files

No files detected



Passive DNS (20)

Passive DNS Source Fully Qualifying Domain Name Rank First Seen Last Seen IP Comment
mnemonic passive DNS push.services.mozilla.com (1) 2140 2015-09-03 10:29:36 UTC 2022-09-27 05:14:54 UTC 52.89.255.30
mnemonic passive DNS www.youtube.com (2) 90 2013-05-30 23:21:49 UTC 2022-09-27 04:57:20 UTC 216.58.211.14
mnemonic passive DNS r3.o.lencr.org (3) 344 2020-12-02 08:52:13 UTC 2022-09-27 04:52:25 UTC 23.36.76.226
mnemonic passive DNS content-signature-2.cdn.mozilla.net (1) 1152 2020-11-03 12:26:46 UTC 2022-09-27 05:14:54 UTC 143.204.55.35
mnemonic passive DNS ocsp.digicert.com (1) 86 2012-05-21 07:02:23 UTC 2022-09-27 21:28:46 UTC 93.184.220.29
mnemonic passive DNS use.typekit.com (3) 14731 2012-05-23 14:28:56 UTC 2022-09-27 15:45:16 UTC 23.36.76.186
mnemonic passive DNS img-getpocket.cdn.mozilla.net (6) 1631 2017-09-01 03:40:57 UTC 2022-09-27 13:22:33 UTC 34.120.237.76
mnemonic passive DNS fonts.gstatic.com (5) 0 2014-08-29 13:43:22 UTC 2022-09-27 04:53:14 UTC 142.250.74.163 Domain (gstatic.com) ranked at: 540
mnemonic passive DNS contile.services.mozilla.com (1) 1114 2021-05-27 18:32:35 UTC 2022-09-27 04:52:33 UTC 34.117.237.239
mnemonic passive DNS fonts.googleapis.com (2) 8877 2013-06-10 20:14:26 UTC 2022-09-27 22:17:28 UTC 142.250.74.10
mnemonic passive DNS use.typekit.net (3) 494 2012-07-05 01:42:39 UTC 2022-09-27 04:53:22 UTC 23.36.76.122
mnemonic passive DNS www.googletagmanager.com (1) 75 2012-12-25 14:52:06 UTC 2022-09-27 04:52:54 UTC 142.250.74.72
mnemonic passive DNS www.google-analytics.com (1) 40 2012-10-03 01:04:21 UTC 2022-09-27 20:10:57 UTC 142.250.74.174
mnemonic passive DNS firefox.settings.services.mozilla.com (2) 867 2020-05-28 17:26:30 UTC 2022-09-27 23:53:35 UTC 143.204.55.27
mnemonic passive DNS s7.addthis.com (3) 1504 2012-05-21 03:34:04 UTC 2022-09-27 05:13:44 UTC 23.38.200.123
mnemonic passive DNS mindfuldog.es (92) 0 2018-04-02 02:00:28 UTC 2022-09-27 03:25:35 UTC 185.209.60.23 Unknown ranking
mnemonic passive DNS m.addthis.com (1) 1448 2013-11-06 20:12:22 UTC 2022-09-27 08:12:33 UTC 23.38.200.123
mnemonic passive DNS ocsp.pki.goog (5) 175 2017-06-14 07:23:31 UTC 2022-09-27 04:53:14 UTC 142.250.74.35
mnemonic passive DNS p.typekit.net (2) 620 2012-05-23 14:28:57 UTC 2022-09-27 04:53:20 UTC 23.36.76.122
mnemonic passive DNS z.moatads.com (1) 374 2014-02-11 16:19:47 UTC 2022-09-27 05:24:49 UTC 23.38.201.146


Recent reports on same IP/ASN/Domain/Screenshot

Last 5 reports on IP: 185.209.60.23

Date UQ / IDS / BL URL IP
2022-11-28 03:26:32 +0000
0 - 0 - 51 mindfuldog.es/ 185.209.60.23
2022-11-09 04:26:37 +0000
0 - 0 - 52 mindfuldog.es/ 185.209.60.23
2022-11-06 03:26:37 +0000
0 - 0 - 51 mindfuldog.es/ 185.209.60.23
2022-09-28 02:25:50 +0000
0 - 0 - 50 mindfuldog.es/ 185.209.60.23
2022-09-26 04:25:53 +0000
0 - 0 - 50 mindfuldog.es/ 185.209.60.23

Last 5 reports on ASN: Euskaltel S.A.

Date UQ / IDS / BL URL IP
2022-11-29 06:04:52 +0000
0 - 0 - 2 busbeauvaisparigi.it/ 185.136.89.218
2022-11-29 05:58:59 +0000
0 - 0 - 41 cityserving.com/ 185.136.89.218
2022-11-29 04:04:02 +0000
0 - 0 - 2 busbeauvaisparigi.it/ 185.136.89.218
2022-11-29 02:06:57 +0000
0 - 0 - 2 help.cityserving.com/ 185.136.89.218
2022-11-28 04:09:42 +0000
0 - 0 - 38 checkout.oasbus.com/ 185.136.89.218

Last 5 reports on domain: mindfuldog.es

Date UQ / IDS / BL URL IP
2022-11-28 03:26:32 +0000
0 - 0 - 51 mindfuldog.es/ 185.209.60.23
2022-11-09 04:26:37 +0000
0 - 0 - 52 mindfuldog.es/ 185.209.60.23
2022-11-06 03:26:37 +0000
0 - 0 - 51 mindfuldog.es/ 185.209.60.23
2022-09-28 02:25:50 +0000
0 - 0 - 50 mindfuldog.es/ 185.209.60.23
2022-09-26 04:25:53 +0000
0 - 0 - 50 mindfuldog.es/ 185.209.60.23

Last 4 reports with similar screenshot

Date UQ / IDS / BL URL IP
2022-09-26 04:25:53 +0000
0 - 0 - 50 mindfuldog.es/ 185.209.60.23
2022-09-25 02:25:50 +0000
0 - 0 - 50 mindfuldog.es/ 185.209.60.23
2022-09-08 04:25:50 +0000
0 - 0 - 49 mindfuldog.es/ 185.209.60.23
2022-09-01 02:25:48 +0000
0 - 0 - 50 mindfuldog.es/ 185.209.60.23


JavaScript

Executed Scripts (80)


Executed Evals (4)

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

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

#2 JavaScript::Eval (size: 8, repeated: 1) - SHA256: 3c4b9b06fe520e9d07b2150eebd412a59c91d789706d99a2b2dc9bf217604d1f

                                        _ate.cbs
                                    

#3 JavaScript::Eval (size: 11, repeated: 1) - SHA256: 8ee784d797ce97ed9716bb42682346deb0c7ae8ff75d7ad8ae60508907054c16

                                        addthis.cbs
                                    

#4 JavaScript::Eval (size: 193350, repeated: 1) - SHA256: a631221fdfb57bfa02649945e7480a82dbda616d52ba74f4245045fc9122c6b2

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

Executed Writes (0)



HTTP Transactions (136)


Request Response
                                        
                                            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=5907
Expires: Wed, 28 Sep 2022 04:04:06 GMT
Date: Wed, 28 Sep 2022 02:25:39 GMT
Connection: keep-alive

                                        
                                            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.27
HTTP/1.1 200 OK
Content-Type: application/json
                                        
Content-Length: 939
Connection: keep-alive
Access-Control-Allow-Origin: *
Access-Control-Expose-Headers: Content-Type, Alert, Backoff, Retry-After, Content-Length
Cache-Control: max-age=3600
Content-Security-Policy: default-src 'none'; frame-ancestors 'none'; base-uri 'none';
Date: Wed, 28 Sep 2022 02:15:37 GMT
X-Content-Type-Options: nosniff
X-Cache: Hit from cloudfront
Via: 1.1 aac54e3fe9825ce24d51e0204433c2c0.cloudfront.net (CloudFront)
X-Amz-Cf-Pop: OSL50-C1
X-Amz-Cf-Id: 4APD7uUAi3d6xUxfSVhqbf7fbuIvrV8R7mqPtDB5NRLe7uZ6iQ4zFQ==
Age: 602


--- 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
                                        
                                            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: Tue, 27 Sep 2022 09:24:14 GMT
etag: "6113f8408c59aebe188d6af273b90743"
x-cache: Hit from cloudfront
via: 1.1 6a757ab2991da716151f94ca00b38098.cloudfront.net (CloudFront)
x-amz-cf-pop: OSL50-C1
x-amz-cf-id: 9GMZYun3Pv8uNXQ0INqQa94wfSc8SHuF9ZE7_LCxRgwGiYztBSgF4w==
age: 61286
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 02:25:39 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
                                        
                                            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.27
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
Cache-Control: max-age=3600, max-age=3600
Date: Wed, 28 Sep 2022 02:10:46 GMT
Expires: Wed, 28 Sep 2022 02:12:27 GMT
ETag: "1648230346554"
X-Cache: Hit from cloudfront
Via: 1.1 095562e8748e634f880ee3c4ada2b6d0.cloudfront.net (CloudFront)
X-Amz-Cf-Pop: OSL50-C1
X-Amz-Cf-Id: O25r7u5RYrd0iUWLcGgsqZXGC2V1fHgf-iKJKR9Q5wJy9L4dIVd0Vg==
Age: 893


--- 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: 4081
Cache-Control: 'max-age=158059'
Date: Wed, 28 Sep 2022 02:25:40 GMT
Last-Modified: Wed, 28 Sep 2022 01:17:39 GMT
Server: ECS (ska/F70C)
X-Cache: HIT
Content-Length: 471

                                        
                                            GET /css?family=Poppins%3A300%2Cregular%2C500%2C600%2C700%7CNunito%3A200%2C200italic%2C300%2C300italic%2Cregular%2Citalic%2C600%2C600italic%2C700%2C700italic%2C900%2C900italic%7CSource+Sans+Pro%3A200%2C200italic%2C300%2C300italic%2Cregular%2Citalic%2C600%2C600italic%2C700%2C700italic%2C900%2C900italic&subset=devanagari%2Clatin-ext%2Cvietnamese%2Clatin&ver=1.0.0 HTTP/1.1 
Host: fonts.googleapis.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
Connection: keep-alive
Referer: http://mindfuldog.es/

                                         
                                         142.250.74.10
HTTP/1.1 200 OK
Content-Type: text/css; charset=utf-8
                                        
Access-Control-Allow-Origin: *
Timing-Allow-Origin: *
Link: <http://fonts.gstatic.com>; rel=preconnect; crossorigin
Expires: Wed, 28 Sep 2022 02:25:40 GMT
Date: Wed, 28 Sep 2022 02:25:40 GMT
Cache-Control: private, max-age=86400
Cross-Origin-Resource-Policy: cross-origin
Cross-Origin-Opener-Policy: same-origin-allow-popups
Content-Encoding: gzip
Transfer-Encoding: chunked
Server: ESF
X-XSS-Protection: 0
X-Frame-Options: SAMEORIGIN
X-Content-Type-Options: nosniff


--- Additional Info ---
Magic:  ASCII text
Size:   1786
Md5:    1c44803a70be3c18dfbd2b9e492ee3a6
Sha1:   9f1da91dc156d93b4ce6c4f0ec704e7fda219d1a
Sha256: 268d77cb6b58ee2648f59764f5a546611cd76f1f00fcd326f659310bbfbf7bd6
                                        
                                            GET /js/300/addthis_widget.js?ver=4.9.21 HTTP/1.1 
Host: s7.addthis.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: http://mindfuldog.es/
Sec-Fetch-Dest: script
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: cross-site

                                         
                                         23.38.200.123
HTTP/2 200 OK
content-type: application/javascript
                                        
server: nginx/1.15.8
last-modified: Mon, 26 Oct 2020 18:11:48 GMT
etag: "5f971164-5834c"
cache-control: public, max-age=600
strict-transport-security: max-age=15724800; includeSubDomains
content-encoding: gzip
content-length: 116360
date: Wed, 28 Sep 2022 02:25:40 GMT
vary: Accept-Encoding
x-distribution: 99
x-host: s7.addthis.com
X-Firefox-Spdy: h2


--- Additional Info ---
Magic:  ASCII text, with very long lines (54602)
Size:   116360
Md5:    5d974241edf8b0e9527678a1368b0119
Sha1:   53101308ccc3a8539cd1e73059be1ef980342c90
Sha256: fcb5fc6ca11a424598604e82eb0cf2d7412f5b0222304c535fe356ea3743be2e
                                        
                                            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: VpQ0VljlfDBN8r3hQySQ+Q==
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

                                         
                                         52.89.255.30
HTTP/1.1 101 Switching Protocols
                                        
Connection: Upgrade
Upgrade: websocket
Sec-WebSocket-Accept: tx106EMPF5TzdDviLoB4cYWuglc=

                                        
                                            GET / HTTP/1.1 
Host: mindfuldog.es
                                        
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

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: text/html; charset=UTF-8
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:40 GMT
Transfer-Encoding: chunked
Connection: keep-alive
Expires: Thu, 19 Nov 1981 08:52:00 GMT
Cache-Control: no-store, no-cache, must-revalidate
Pragma: no-cache
Link: <http://mindfuldog.es/wp-json/>; rel="https://api.w.org/", <http://mindfuldog.es/>; rel=shortlink
Set-Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke; path=/
X-Powered-By: PHP/7.1.33, PleskLin


--- 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 text\012- exported SGML document, Unicode text, UTF-8 text, with very long lines (9480), with CRLF, LF line terminators
Size:   87825
Md5:    3bb36c2c93777ae1184f267aa6d51e3a
Sha1:   53b78c50bc77ba022508c0a2827ef5641ad95c66
Sha256: 232051ad2ac091356fb800f89b709a86cf69bd10d81a6dd6de13db3552545ecd

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            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.35
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Date: Wed, 28 Sep 2022 02:25:40 GMT
Cache-Control: public, max-age=14400
Server: ocsp_responder
Content-Length: 471
X-XSS-Protection: 0
X-Frame-Options: SAMEORIGIN

                                        
                                            GET /wp-content/plugins/LayerSlider/static/layerslider/css/layerslider.css?ver=6.6.4 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:40 GMT
Content-Length: 21133
Last-Modified: Wed, 03 Jan 2018 13:31:10 GMT
Connection: keep-alive
ETag: "5a4cdb1e-528d"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text
Size:   21133
Md5:    dcb2cfe7cd3486cf3c9c6bf1c3f82561
Sha1:   b212ed83cf9faaf4228241cb1218d68fdb02aa64
Sha256: 664d93fd1340038b753322dc70e1147852c70739d103e801c8b5d626863066c9
                                        
                                            GET /wp-content/plugins/contact-form-7/includes/css/styles.css?ver=5.0.2 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:40 GMT
Content-Length: 1683
Last-Modified: Tue, 12 Jun 2018 13:30:13 GMT
Connection: keep-alive
ETag: "5b1fcae5-693"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text
Size:   1683
Md5:    fc2e6559fc8d9fc13c67481ff30d7cc8
Sha1:   eabc53e08cc444b7255bd97f00f6611d2eb8538b
Sha256: 1e36067ffbde51faec89f96ebe1fd08513be4a97d109cc8130dcdc9cf3f4590d
                                        
                                            GET /wp-content/plugins/photo-gallery/css/bwg_frontend.css?ver=1.4.5 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:40 GMT
Content-Length: 7927
Last-Modified: Thu, 26 Apr 2018 11:00:27 GMT
Connection: keep-alive
ETag: "5ae1b14b-1ef7"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text
Size:   7927
Md5:    44fb918418c0a99da52caf3ab8d64ab5
Sha1:   d599de8b0fdfeadb29461a474488c90e224d0282
Sha256: acc151ec52398d796703fd4ada42a24e77acff689657fc1e3e823a2a0ee555a8

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /wp-content/plugins/photo-gallery/css/sumoselect.css?ver=3.0.2 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:40 GMT
Content-Length: 8690
Last-Modified: Thu, 26 Apr 2018 11:00:27 GMT
Connection: keep-alive
ETag: "5ae1b14b-21f2"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text, with very long lines (516)
Size:   8690
Md5:    ccfbd12b9b34c29639dd9c39f22bc00e
Sha1:   612f5e471ae3cb99d214d7751c2534836267efce
Sha256: 0d23f402d9e83ea351b6b1a9e9b03ee3f94a9b41bd95e64da24e637753bf4dad
                                        
                                            GET /bex7qnl.css HTTP/1.1 
Host: use.typekit.net
                                        
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: http://mindfuldog.es/
Sec-Fetch-Dest: style
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: cross-site

                                         
                                         23.36.76.122
HTTP/2 200 OK
content-type: text/css;charset=utf-8
                                        
server: nginx
vary: Accept-Encoding
strict-transport-security: max-age=31536000; includeSubDomains;
cache-control: private, max-age=600, stale-while-revalidate=604800
timing-allow-origin: *
access-control-allow-origin: *
cross-origin-resource-policy: cross-origin
content-encoding: gzip
content-length: 646
date: Wed, 28 Sep 2022 02:25:40 GMT
X-Firefox-Spdy: h2


--- Additional Info ---
Magic:  Unicode text, UTF-8 text, with very long lines (516)
Size:   646
Md5:    a9e32dc8d1f3840eff5a7d112c7c5868
Sha1:   61030b1d96a4a0ef59b6c84b995a90bb3f543ae4
Sha256: 9c8890b4cd045b142ea0e507762b6729a02f830c5081b2c6295e641281135e10
                                        
                                            GET /bex7qnl.js HTTP/1.1 
Host: use.typekit.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
Connection: keep-alive
Referer: http://mindfuldog.es/

                                         
                                         23.36.76.186
HTTP/1.1 200 OK
Content-Type: text/javascript;charset=utf-8
                                        
Server: nginx
Vary: Accept-Encoding
Strict-Transport-Security: max-age=31536000; includeSubDomains;
Cache-Control: public, max-age=600, stale-while-revalidate=604800
Timing-Allow-Origin: *
Access-Control-Allow-Origin: *
Cross-Origin-Resource-Policy: cross-origin
Content-Encoding: gzip
Content-Length: 6681
Date: Wed, 28 Sep 2022 02:25:40 GMT
Connection: keep-alive


--- Additional Info ---
Magic:  Unicode text, UTF-8 text, with very long lines (2258)
Size:   6681
Md5:    376d06eea0b13b82d5e73680f126890f
Sha1:   17847ad49c7953aeef1acabcfedfd27a5b88c103
Sha256: 20e3890072d97474b73a727f1b2449ef12d0069914177360414585084effb296
                                        
                                            GET /wp-content/plugins/photo-gallery/css/jquery.mCustomScrollbar.css?ver=1.4.5 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:40 GMT
Content-Length: 13224
Last-Modified: Thu, 26 Apr 2018 11:00:27 GMT
Connection: keep-alive
ETag: "5ae1b14b-33a8"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text
Size:   13224
Md5:    134d36ccd55a3865fccee8ffa9840c2f
Sha1:   cc10fbd8363394dae26d6a954f27d2b7cf8e5a14
Sha256: bbf8b025f38fc6aef74423424106cc06be1b91e2c794cff8d9bf1e5b9a3ddfbb

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /p.css?s=1&k=bex7qnl&ht=tk&f=32874.32875&a=7368863&app=typekit&e=css HTTP/1.1 
Host: p.typekit.net
                                        
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://use.typekit.net/
Sec-Fetch-Dest: style
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: same-site
TE: trailers

                                         
                                         23.36.76.122
HTTP/2 200 OK
content-type: text/css
                                        
accept-ranges: bytes
access-control-allow-origin: *
cache-control: public, max-age=604800
cross-origin-resource-policy: cross-origin
etag: "613bee4d-5"
last-modified: Fri, 10 Sep 2021 23:46:21 GMT
server: nginx
content-length: 5
unused62: 8096267
date: Wed, 28 Sep 2022 02:25:40 GMT
X-Firefox-Spdy: h2


--- Additional Info ---
Magic:  ASCII text
Size:   5
Md5:    83d24d4b43cc7eef2b61e66c95f3d158
Sha1:   f0cafc285ee23bb6c28c5166f305493c4331c84d
Sha256: 1c0ff118a4290c99f39c90abb38703a866e47251b23cca20266c69c812ccafeb
                                        
                                            GET /wp-content/plugins/photo-gallery/css/font-awesome/font-awesome.css?ver=4.6.3 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:40 GMT
Content-Length: 35376
Last-Modified: Thu, 26 Apr 2018 11:00:27 GMT
Connection: keep-alive
ETag: "5ae1b14b-8a30"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text, with very long lines (357)
Size:   35376
Md5:    6480d42fb358be80424835fbcdf28876
Sha1:   f76e6f6db4a64748638cb82faa5230f89d1b306c
Sha256: 3e825e4cd826af209f652088971f7047fbe31acdeda049a078103933e8999a95
                                        
                                            GET /wp-content/plugins/wwm-social-share-on-image-hover/css/wwm_custom.css?ver=4.9.21 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:40 GMT
Content-Length: 1903
Last-Modified: Thu, 26 Apr 2018 10:09:35 GMT
Connection: keep-alive
ETag: "5ae1a55f-76f"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text, with very long lines (1579)
Size:   1903
Md5:    416579bd785c22fa79ed58ad39c20ab1
Sha1:   55a286d020b25bccecff22f5f819c85c566743a7
Sha256: 9b13828ecfd7f2b3dac9946441d8445790166cab892083793ca1911d9270d1b7
                                        
                                            GET /wp-content/plugins/uk-cookie-consent/assets/css/style.css?ver=4.9.21 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:40 GMT
Content-Length: 4356
Last-Modified: Thu, 26 Apr 2018 11:15:50 GMT
Connection: keep-alive
ETag: "5ae1b4e6-1104"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text, with CRLF line terminators
Size:   4356
Md5:    3c550a68a691fe46c5e9316be3a2be3b
Sha1:   1fbf83af652c98421de03a8160b3c215b699f7db
Sha256: 7e6be601cd253ab851b351a4484520682afa8ceb8b77a0d8d5664335f04b6905
                                        
                                            GET /wp-includes/js/wp-emoji-release.min.js?ver=4.9.21 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:40 GMT
Content-Length: 11943
Last-Modified: Fri, 16 Apr 2021 00:30:20 GMT
Connection: keep-alive
ETag: "6078da9c-2ea7"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text, with very long lines (9063)
Size:   11943
Md5:    fe0575b66568074463f12485d90f6d4c
Sha1:   aeedd9ab3b7874e63f647042963cb1301a38b391
Sha256: 647a6b36f3fd1f21bae171270111096b4613c23a47e6621628a51bae9c82b0b7

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /wp-content/themes/uncode-child/style.css?ver=592795229 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:40 GMT
Content-Length: 176
Connection: keep-alive
X-Accel-Version: 0.01
Last-Modified: Wed, 03 Jan 2018 13:20:26 GMT
ETag: "b0-561df14223f23"
Accept-Ranges: bytes
X-Powered-By: PleskLin


--- Additional Info ---
Magic:  Unicode text, UTF-8 text
Size:   176
Md5:    2ed2cfcebd7a8ab6e50df47a2aef0e0d
Sha1:   3a7678c62663d3ad069cb648fb9782229a3957cd
Sha256: 49ae2ab3d2248292ba674b271aab8792d7e0c5d266553076fade08efda7051cf

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /wp-content/plugins/revslider/public/assets/css/settings.css?ver=5.4.6.3.1 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:40 GMT
Content-Length: 30072
Last-Modified: Wed, 03 Jan 2018 13:33:19 GMT
Connection: keep-alive
ETag: "5a4cdb9f-7578"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text, with very long lines (29701), with CRLF line terminators
Size:   30072
Md5:    c4ce361995ff4e22f22c79d0ead65f35
Sha1:   2d07f0f1b10bef9b90540bb14181c019b0a32c2e
Sha256: b0b1b6ccfa5a09e69e2e1e89777043a637e23f5b9aecc0a3a86e04495804b239

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            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.35
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Date: Wed, 28 Sep 2022 02:25:40 GMT
Cache-Control: public, max-age=14400
Server: ocsp_responder
Content-Length: 471
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: 83
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache

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

                                        
                                            GET /wp-content/plugins/addthis/frontend/build/addthis_wordpress_public.min.css?ver=4.9.21 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:40 GMT
Content-Length: 587
Connection: keep-alive
X-Accel-Version: 0.01
Last-Modified: Thu, 26 Apr 2018 12:27:07 GMT
ETag: "24b-56abf817c2571"
Accept-Ranges: bytes
X-Powered-By: PleskLin


--- Additional Info ---
Magic:  ASCII text, with very long lines (504)
Size:   587
Md5:    74ef44ae2edb68d989b2bec4d4f2310f
Sha1:   a9f7de2f2957abcf0a8f8dbd612d87846af4cd4a
Sha256: d1870c49e74adfa2d70351cc067c6a3320da45d18231c5a31eb39356151620cb

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /wp-content/plugins/jquery-validation-for-contact-form-7/includes/assets/css/jvcf7_client.css?ver=5.3 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:40 GMT
Content-Length: 303
Connection: keep-alive
X-Accel-Version: 0.01
Last-Modified: Mon, 27 Jun 2022 14:34:25 GMT
ETag: "12f-5e26ed10ef709"
Accept-Ranges: bytes
X-Powered-By: PleskLin


--- Additional Info ---
Magic:  ASCII text, with CRLF line terminators
Size:   303
Md5:    11cdd6c918c6949bc193d978edd28253
Sha1:   aa22dd25ca341b24b679e0e6a68923b1572a821e
Sha256: d22b66d85f390af3889a96a72edfd02b1e0449f9fb989f162c683609cab5f1cc

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /gtag/js?id=UA-111931717-1 HTTP/1.1 
Host: www.googletagmanager.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: http://mindfuldog.es/
Sec-Fetch-Dest: script
Sec-Fetch-Mode: no-cors
Sec-Fetch-Site: cross-site

                                         
                                         142.250.74.72
HTTP/2 200 OK
content-type: application/javascript; charset=UTF-8
                                        
access-control-allow-origin: *
access-control-allow-credentials: true
access-control-allow-headers: Cache-Control
content-encoding: br
vary: Accept-Encoding
date: Wed, 28 Sep 2022 02:25:40 GMT
expires: Wed, 28 Sep 2022 02:25:40 GMT
cache-control: private, max-age=900
last-modified: Wed, 28 Sep 2022 00:00:00 GMT
strict-transport-security: max-age=31536000; includeSubDomains
cross-origin-resource-policy: cross-origin
server: Google Tag Manager
content-length: 42334
x-xss-protection: 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:  ASCII text, with very long lines (2039)
Size:   42334
Md5:    0ab76002dfe0f1b7003f276cbb8eb5a2
Sha1:   803ab6c4ac98cf361dbe9fcdcec7c5ab9391d866
Sha256: 7ffdef308b3ed91146a6a30a225fc0589046d207eed3b837327e870ba25a951c
                                        
                                            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.35
HTTP/1.1 200 OK
Content-Type: application/ocsp-response
                                        
Date: Wed, 28 Sep 2022 02:25:40 GMT
Cache-Control: public, max-age=14400
Server: ocsp_responder
Content-Length: 471
X-XSS-Protection: 0
X-Frame-Options: SAMEORIGIN

                                        
                                            GET /wp-content/themes/uncode/library/css/uncode-icons.css?ver=178556683 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:40 GMT
Content-Length: 61860
Last-Modified: Wed, 03 Jan 2018 13:20:39 GMT
Connection: keep-alive
ETag: "5a4cd8a7-f1a4"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  troff or preprocessor input, ASCII text
Size:   61860
Md5:    8ba002d01fd0ae1ffbd6916d1060dc2f
Sha1:   b4fea1784d1deb040d18d55ce051f8083c0ca373
Sha256: f6513e8c18547d8923f7183a2efd2fcdb51432dd1ede4f127732fb0d43c164e1

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /wp-content/themes/uncode/library/css/style.css?ver=592795229 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:40 GMT
Content-Length: 378971
Last-Modified: Wed, 03 Jan 2018 13:20:39 GMT
Connection: keep-alive
ETag: "5a4cd8a7-5c85b"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text
Size:   378971
Md5:    8c1a65c83c1b1010d202e034e6bee37a
Sha1:   1b514b4066ab6ef9240e5aafabe5a548712fafc1
Sha256: c3cd450093ae4164b44e109c06f369813ebc53a91c6f7856066e9366a068c8e0

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /wp-includes/js/jquery/jquery-migrate.min.js?ver=1.4.1 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:40 GMT
Content-Length: 10056
Last-Modified: Tue, 26 Dec 2017 16:40:52 GMT
Connection: keep-alive
ETag: "5a427b94-2748"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text, with very long lines (9959)
Size:   10056
Md5:    7121994eec5320fbe6586463bf9651c2
Sha1:   90532aff6d4121954254cdf04994d834f7ec169b
Sha256: 48eb8b500ae6a38617b5738d2b3faec481922a7782246e31d2755c034a45cd5d

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /wp-content/themes/uncode/library/css/woocommerce.css?ver=514051736 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: text/css
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:40 GMT
Content-Length: 110376
Last-Modified: Wed, 03 Jan 2018 13:20:39 GMT
Connection: keep-alive
ETag: "5a4cd8a7-1af28"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text
Size:   110376
Md5:    26e3041b44f20607fb710ff47e61f993
Sha1:   5a861700e93499db1713e286af5d933e33e30d2b
Sha256: a4c19a040333aea3ff255b6a814286901f0edbf044da8c1f1ba5d14e5603a40e

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /wp-content/plugins/LayerSlider/static/layerslider/js/layerslider.transitions.js?ver=6.6.4 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:41 GMT
Content-Length: 23831
Last-Modified: Wed, 03 Jan 2018 13:31:10 GMT
Connection: keep-alive
ETag: "5a4cdb1e-5d17"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  Unicode text, UTF-8 text, with very long lines (23514)
Size:   23831
Md5:    ab5c641341135bae9cde257a14da0656
Sha1:   386804e789461da7b84d5e6e180ae87e67276dc8
Sha256: 7f612443943aaf092378e9fa4082d03bb33e0a4430b19f51fe16077e66729db3

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /wp-content/plugins/LayerSlider/static/layerslider/js/layerslider.kreaturamedia.jquery.js?ver=6.6.4 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:41 GMT
Content-Length: 116289
Last-Modified: Wed, 03 Jan 2018 13:31:10 GMT
Connection: keep-alive
ETag: "5a4cdb1e-1c641"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text, with very long lines (65335)
Size:   116289
Md5:    9910a307b810cfd5e590a49df594a17a
Sha1:   c6fe48676aaf63f65bc004db1ee7a0ddcdb14521
Sha256: 31115198de695e206614fb6fa903a2863335da8e2c58edbe90fec97a4c9798b8

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /wp-content/plugins/photo-gallery/js/bwg_frontend.js?ver=1.4.5 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:41 GMT
Content-Length: 7579
Last-Modified: Thu, 26 Apr 2018 11:00:27 GMT
Connection: keep-alive
ETag: "5ae1b14b-1d9b"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text
Size:   7579
Md5:    d0f688460723b13560d919da63e88590
Sha1:   fbcfe6770289f43a61ccf4db60e30cc924365c27
Sha256: 0770c2cfaad049b403e028ca868a6621cf53d6ecbb3c7f6e24463254b83b30fc
                                        
                                            GET /wp-content/plugins/photo-gallery/js/jquery.sumoselect.min.js?ver=3.0.2 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:41 GMT
Content-Length: 11780
Last-Modified: Thu, 26 Apr 2018 11:00:27 GMT
Connection: keep-alive
ETag: "5ae1b14b-2e04"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text, with very long lines (11692)
Size:   11780
Md5:    ba1220160c45d126b5b4ef26568d484c
Sha1:   c415d7f855e14face2d07d14becec39d833aef40
Sha256: ab3290fa762379839c1f6b170f99505c84aef28f7f67918e2bfa21246b99c541
                                        
                                            GET /wp-content/plugins/photo-gallery/js/jquery.mobile.js?ver=1.4.5 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:41 GMT
Content-Length: 6418
Last-Modified: Thu, 26 Apr 2018 11:00:27 GMT
Connection: keep-alive
ETag: "5ae1b14b-1912"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text, with very long lines (6322)
Size:   6418
Md5:    63d1efa154bd0728b1dcb3c4abee929d
Sha1:   b29b779e8b5fc5809e25343858a7d73ee4c93a02
Sha256: d50e992ac846d1a23ac3fde9ddc997a572fc65702611c667b0a758cf8ee99083

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /wp-content/plugins/photo-gallery/js/jquery.mCustomScrollbar.concat.min.js?ver=1.4.5 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:41 GMT
Content-Length: 25168
Last-Modified: Thu, 26 Apr 2018 11:00:27 GMT
Connection: keep-alive
ETag: "5ae1b14b-6250"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text, with very long lines (24110)
Size:   25168
Md5:    c0efc8c25969b270348069a176e93f8c
Sha1:   39680ef85bdbec350f35e41de4bfca303f5dc34f
Sha256: db06dcfa0112b05cef7abd20fadc5baf632a316515f07cfd4fceb436c8a0cb1b

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /wp-content/plugins/photo-gallery/js/jquery.fullscreen-0.4.1.js?ver=0.4.1 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:41 GMT
Content-Length: 7583
Last-Modified: Thu, 26 Apr 2018 11:00:27 GMT
Connection: keep-alive
ETag: "5ae1b14b-1d9f"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text
Size:   7583
Md5:    a20ccc97b8ab6324adeb56fa34a04c55
Sha1:   bd9ceb6f34eac052e13bb21f76ce83f7334841d2
Sha256: 19e3bcd44b9c726bc12f4138ee4dece9f85487a7b54ea467f6444e323de2207f

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /wp-content/plugins/LayerSlider/static/layerslider/js/greensock.js?ver=1.19.0 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:41 GMT
Content-Length: 117557
Last-Modified: Wed, 03 Jan 2018 13:31:10 GMT
Connection: keep-alive
ETag: "5a4cdb1e-1cb35"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text, with very long lines (32006)
Size:   117557
Md5:    150324e55a09a90e1eface0a7faed270
Sha1:   0fe9f52c3c351c06f5cdb80f86d1aa70a52c4140
Sha256: dfc519eb2d0e5ac0e8cdbe86fef355135280c643df14fa9a8e6abd5820d01159

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /wp-includes/js/jquery/jquery.js?ver=1.12.4 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:40 GMT
Content-Length: 96874
Last-Modified: Fri, 06 Sep 2019 00:30:12 GMT
Connection: keep-alive
ETag: "5d71a894-17a6a"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text, with very long lines (31997)
Size:   96874
Md5:    dc5ba5044fccc0297be7b262ce669a7c
Sha1:   f137ff98ae379e35b0702967d3b6866a0a40e3be
Sha256: cf34e1b87bbfd9d9b185dec994924a496e279d8dc9387ad8d35bc0110134c4d3

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /wp-content/plugins/photo-gallery/js/bwg_gallery_box.js?ver=1.4.5 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:41 GMT
Content-Length: 10489
Last-Modified: Thu, 26 Apr 2018 11:00:27 GMT
Connection: keep-alive
ETag: "5ae1b14b-28f9"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text
Size:   10489
Md5:    60d5f5989c7d6c6a225e566fab573e15
Sha1:   88612ef82743949dee9fb0cde8827f654a948eb6
Sha256: 0615ccecb1d5e7af0a23bd9cfc3b2e3615a1146457a786c8735be51e5cbed096
                                        
                                            GET /wp-content/plugins/revslider/public/assets/js/jquery.themepunch.tools.min.js?ver=5.4.6.3.1 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:41 GMT
Content-Length: 110563
Last-Modified: Wed, 03 Jan 2018 13:33:19 GMT
Connection: keep-alive
ETag: "5a4cdb9f-1afe3"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text, with very long lines (27287), with CRLF line terminators
Size:   110563
Md5:    a748a9e56b2c639013c770506f1fd529
Sha1:   537edd9b364ac005df2d1c57be873945b2fecdf6
Sha256: 6eabb193731278713f4208ea84b8c7334c3dfc98f01cb074778280e1df536e62

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /wp-content/plugins/revslider/public/assets/js/jquery.themepunch.revolution.min.js?ver=5.4.6.3.1 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:41 GMT
Content-Length: 64792
Last-Modified: Wed, 03 Jan 2018 13:33:19 GMT
Connection: keep-alive
ETag: "5a4cdb9f-fd18"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text, with very long lines (64455), with CRLF line terminators
Size:   64792
Md5:    ea632fb18aac2217265de8d583284476
Sha1:   ea93c8af55049ccc41a02878b9c40303b317423f
Sha256: 5c66c3c106dc8c518f76ddf6921166fbbbd755b7c5586adc4f9171db0a7eb3df
                                        
                                            GET /wp-content/plugins/woocommerce/assets/js/frontend/add-to-cart.min.js?ver=3.3.4 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:41 GMT
Content-Length: 2650
Last-Modified: Mon, 02 Apr 2018 09:15:58 GMT
Connection: keep-alive
ETag: "5ac1f4ce-a5a"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  HTML document, ASCII text, with very long lines (2650), with no line terminators
Size:   2650
Md5:    05d91714389e25b05a00376d63101ad6
Sha1:   638b08ff6b591ae48bb67c0c9963461b8fbfb3be
Sha256: 78a4687788a4631915d33652efe328da6aefec2b23fe5528c336d605d90ed11a

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /wp-content/plugins/wwm-social-share-on-image-hover/js/wwm_custom.js?ver=4.9.21 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:41 GMT
Content-Length: 6044
Last-Modified: Thu, 26 Apr 2018 10:09:35 GMT
Connection: keep-alive
ETag: "5ae1a55f-179c"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  Unicode text, UTF-8 text
Size:   6044
Md5:    ac057746548eb8f49dae0798acda30a7
Sha1:   6b1521d62c5edb2abe617bddcac885256f3a3bd6
Sha256: 03b51239c3da0712501d3f209eaa2875e73c48a561da0be6c6948987aa10c259

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /wp-content/plugins/uncode-js_composer/assets/js/vendors/woocommerce-add-to-cart.js?ver=5.4.5 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:41 GMT
Content-Length: 895
Connection: keep-alive
X-Accel-Version: 0.01
Last-Modified: Wed, 03 Jan 2018 13:28:03 GMT
ETag: "37f-561df2f55fde3"
Accept-Ranges: bytes
X-Powered-By: PleskLin


--- Additional Info ---
Magic:  ASCII text
Size:   895
Md5:    902b7ca09549975e55e136fb0026df9a
Sha1:   ae9b808c87bbbf57b9f3132c41effaaa12af03ff
Sha256: 2685c1caf9a3e6616da70c63212ff6d6a6747e4929edf55832ebd18ef7a43ccf

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            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: "0E47D6E33FE9F6E588D308B62FA059C960A000C56651713E30BAF6CD09B7DE41"
Last-Modified: Sun, 25 Sep 2022 22:00:00 UTC
Cache-Control: public, no-transform, must-revalidate, max-age=4175
Expires: Wed, 28 Sep 2022 03:35:16 GMT
Date: Wed, 28 Sep 2022 02:25:41 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: "0E47D6E33FE9F6E588D308B62FA059C960A000C56651713E30BAF6CD09B7DE41"
Last-Modified: Sun, 25 Sep 2022 22:00:00 UTC
Cache-Control: public, no-transform, must-revalidate, max-age=4175
Expires: Wed, 28 Sep 2022 03:35:16 GMT
Date: Wed, 28 Sep 2022 02:25:41 GMT
Connection: keep-alive

                                        
                                            GET /wp-includes/js/mediaelement/mediaelement-migrate.min.js?ver=4.9.21 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:41 GMT
Content-Length: 1193
Last-Modified: Fri, 16 Apr 2021 00:30:20 GMT
Connection: keep-alive
ETag: "6078da9c-4a9"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text, with very long lines (1193), with no line terminators
Size:   1193
Md5:    f34f415aa56ed900eecf3f212adb57e2
Sha1:   352dfeec21817198c07ab11705b53d813420cea3
Sha256: 7f34b768792b90cf0b04fced2470e43d8fab7644f6565d5178fbfb49c4859cee

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /296x148/filters:format(jpeg):quality(60):no_upscale():strip_exif()/https%3A%2F%2Fs3.amazonaws.com%2Fpocket-curatedcorpusapi-prod-images%2Ffb17f4e8-cf01-41dc-8d4d-247daf3e0160.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: 14018
x-amzn-requestid: fb0f02e7-1ce0-4861-9446-13d60df06f24
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: ZI3xSEhCIAMFWkQ=
x-content-type-options: nosniff
x-amzn-trace-id: Root=1-63336cd4-79f482493d204a1208fad00f;Sampled=0
x-amzn-remapped-date: Tue, 27 Sep 2022 21:36:20 GMT
x-amz-cf-pop: HIO50-C1, SEA73-P1
x-cache: Hit from cloudfront
x-amz-cf-id: ZAov4fpWAjIBhHfeYEwu39wJTG58HnW7ebekpIoNSgA7PLIs5b7sSg==
via: 1.1 4d7fa73f804f1c93f20cfc24c4b1266e.cloudfront.net (CloudFront), 1.1 ebe4011a81a36e2bf678f69ce1711330.cloudfront.net (CloudFront), 1.1 google
date: Tue, 27 Sep 2022 22:28:52 GMT
age: 14209
etag: "78b1a603c4f7f2d6fbad15d7a4cd1397554339e9"
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:   14018
Md5:    d039db0b842a4cbbaefdaab98bc6722b
Sha1:   78b1a603c4f7f2d6fbad15d7a4cd1397554339e9
Sha256: 65a3c7b0515cfd2a723f3bc3147cb98f3dd75ce1ecfce915c7c8e9ba5ae0bf2d
                                        
                                            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: 16603
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%2Fb9a3b058-92c9-490e-9cbb-736f7e46510d.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: 7455
x-amzn-requestid: e99c9f33-b72a-4070-80cf-06fb4a87d1df
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: ZG4S6EcAoAMFX1A=
x-content-type-options: nosniff
x-amzn-trace-id: Root=1-6332a0df-04122b4a345dbc3f3918af98;Sampled=0
x-amzn-remapped-date: Tue, 27 Sep 2022 07:06:07 GMT
x-amz-cf-pop: HIO50-C1, SEA73-P1
x-cache: Hit from cloudfront
x-amz-cf-id: yprErfM7s7P7jJPJT-HQZ2Z_AAN4946Tjwyn1g4r7yiA6IF0yLdQTQ==
via: 1.1 eece508272520f70691e4eebdc5a6dea.cloudfront.net (CloudFront), 1.1 1508efc4152aa1778ed4adecb328b374.cloudfront.net (CloudFront), 1.1 google
date: Tue, 27 Sep 2022 07:35:49 GMT
age: 67792
etag: "b383135e2ebc23fe80eb0d594b198cb8c89327a5"
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:   7455
Md5:    ea3890e460356d6ecc3ba4e405ac2e9e
Sha1:   b383135e2ebc23fe80eb0d594b198cb8c89327a5
Sha256: 8fcff053ce6e5750136bf876bad5b2916935f13ea039912d977928b086f0a48b
                                        
                                            GET /296x148/filters:format(jpeg):quality(60):no_upscale():strip_exif()/https%3A%2F%2Fs3.amazonaws.com%2Fpocket-curatedcorpusapi-prod-images%2Fd5653a1a-a7d7-4b1e-a27e-4eb6b032901d.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: 11314
x-amzn-requestid: 0ceafc65-764c-4367-b031-257061eb65d4
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: ZI3UPF00oAMFUpw=
x-content-type-options: nosniff
x-amzn-trace-id: Root=1-63336c1a-0d46481b7394081b14a81131;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: ve8l6PxpMuBLt5BxwywNpqM2ISt0zy2r_gweYnVw4X65PBEhpMbckg==
via: 1.1 eece508272520f70691e4eebdc5a6dea.cloudfront.net (CloudFront), 1.1 2324edbcb8fc72f617442c65f36a40fc.cloudfront.net (CloudFront), 1.1 google
date: Tue, 27 Sep 2022 21:46:00 GMT
age: 16781
etag: "8ad289a77705358ab660b6123e9d90de991b6c13"
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:   11314
Md5:    ee83d08d024d127fad5918e1ffacb78b
Sha1:   8ad289a77705358ab660b6123e9d90de991b6c13
Sha256: aaab3590ef3777ce8b7a9a34f18866fa20ecaa554cbcdcdb3f1fa3c34c88ceb4
                                        
                                            GET /296x148/filters:format(jpeg):quality(60):no_upscale():strip_exif()/https%3A%2F%2Fs3.amazonaws.com%2Fpocket-curatedcorpusapi-prod-images%2F02722822-e024-44b9-8ec1-48ec9500ca58.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: 9733
x-amzn-requestid: fff8214b-48f7-4b45-bd91-69ea4db871d6
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: ZCAWhG9HIAMFloQ=
x-content-type-options: nosniff
x-amzn-trace-id: Root=1-6330adc3-1cffa63711378c525e49e11d;Sampled=0
x-amzn-remapped-date: Sun, 25 Sep 2022 19:36:35 GMT
x-amz-cf-pop: SEA73-P1
x-cache: Hit from cloudfront
x-amz-cf-id: Vak91l2UKRnX0Go62y1yPwJ8E-Af7XBurmQATw5MSZXBqhUJrIgOCQ==
via: 1.1 0dc4feb22bb4657ce2bb95fd05ec7122.cloudfront.net (CloudFront), 1.1 6396e88c437c096ef98930ce29f731a2.cloudfront.net (CloudFront), 1.1 google
date: Tue, 27 Sep 2022 04:59:08 GMT
age: 77193
etag: "2142075b27d0d355c51231ab06fea46e25eb9c59"
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:   9733
Md5:    f3e1fd3401c5e635a8dbeec5f78b721d
Sha1:   2142075b27d0d355c51231ab06fea46e25eb9c59
Sha256: 2e17a43985b624e6b6592d402c36dd45b915cd6e1ac84e187c18c46420eb9a1d
                                        
                                            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: 16623
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 /wp-content/themes/uncode/library/js/min/ai-uncode.min.js HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:41 GMT
Content-Length: 1962
Last-Modified: Wed, 03 Jan 2018 13:21:06 GMT
Connection: keep-alive
ETag: "5a4cd8c2-7aa"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text, with very long lines (1962), with no line terminators
Size:   1962
Md5:    2c0134e8f13dd0d5fee86feafb07aa74
Sha1:   b61f4d7ccde119a68487bab9cf88e05a586a253c
Sha256: 7a55bcac306c833c1cc13af24f987fa01c5323bfbd540a4feafcf2b274f59e3b

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /wp-content/plugins/wonderplugin-lightbox/engine/wonderpluginlightbox.js?ver=6.1 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:41 GMT
Content-Length: 97980
Last-Modified: Thu, 04 Jan 2018 13:18:34 GMT
Connection: keep-alive
ETag: "5a4e29aa-17ebc"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text, with very long lines (704)
Size:   97980
Md5:    595db67820d0814414c950c4d66e4953
Sha1:   b34b0f19ead68682bede1f805c8331deaac89c69
Sha256: 297fc3b37014c33d004395d9eb595e0c57096dabae21c92fa943d9a0203633ff

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /wp-includes/js/underscore.min.js?ver=1.8.3 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:41 GMT
Content-Length: 16410
Last-Modified: Tue, 26 Dec 2017 16:40:53 GMT
Connection: keep-alive
ETag: "5a427b95-401a"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text, with very long lines (16194)
Size:   16410
Md5:    6a3a434a1360cc744341e97de9177bc6
Sha1:   d110825c3252a677ce8b6fd81cd2eda0201e4e1b
Sha256: 4f5b2528815d8b1cd9b68b1a4bb1fe689696f8dcbc2c4a5104343b886ee68828

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /wp-content/plugins/uncode-daves-wordpress-live-search/js/daves-wordpress-live-search.js?ver=4.9.21 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:41 GMT
Content-Length: 11648
Last-Modified: Wed, 03 Jan 2018 13:35:20 GMT
Connection: keep-alive
ETag: "5a4cdc18-2d80"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text
Size:   11648
Md5:    b60c96ac978e5b845d11af7882e83e03
Sha1:   4bc33f78ee16d6d8673ac1ce5334df20ac358b96
Sha256: 25eec942a7566afcd7715f0872c9f6525b51bc13776b027c12c2d9565b73dce3
                                        
                                            GET /wp-content/plugins/contact-form-7/includes/js/scripts.js?ver=5.0.2 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:41 GMT
Content-Length: 14585
Last-Modified: Tue, 12 Jun 2018 13:30:13 GMT
Connection: keep-alive
ETag: "5b1fcae5-38f9"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text
Size:   14585
Md5:    80f051b85c7cc301d20dc6c522c71814
Sha1:   d8344eee926ebe2f35396f51cfa5614cb4307b40
Sha256: c6138c4b65aaff6e46d51c26096ffffadd202974003ad0f6d4475b45204bd0ab

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /wp-content/plugins/i-recommend-this/js/dot_irecommendthis.js?ver=2.6.0 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:41 GMT
Content-Length: 513
Connection: keep-alive
X-Accel-Version: 0.01
Last-Modified: Wed, 03 Jan 2018 13:30:54 GMT
ETag: "201-561df398a0d63"
Accept-Ranges: bytes
X-Powered-By: PleskLin


--- Additional Info ---
Magic:  ASCII text, with CRLF line terminators
Size:   513
Md5:    6c3dc4520423c4ac8340bf1966a2639e
Sha1:   c451367fca7e032f5f533b00af112cc64a77ac95
Sha256: 8908c5cf58d0b51f4050170ca34423d5fa5669ddb900b5d5fd0ba8f47bd9dbc8
                                        
                                            GET /wp-content/plugins/uk-cookie-consent/assets/js/uk-cookie-consent-js.js?ver=2.3.0 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:41 GMT
Content-Length: 1581
Last-Modified: Thu, 26 Apr 2018 11:15:50 GMT
Connection: keep-alive
ETag: "5ae1b4e6-62d"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text, with CRLF line terminators
Size:   1581
Md5:    cabf33db444541a84cfb31ca3a3b81b0
Sha1:   880c838a694ee52956ee62c497e9732e391696f9
Sha256: 2e52aa532594524ce54ab7f748eb9828e2285b705ba1da5fe5b4c0f4ada6ce1a

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /wp-content/plugins/woocommerce/assets/js/jquery-blockui/jquery.blockUI.min.js?ver=2.70 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:41 GMT
Content-Length: 9566
Last-Modified: Mon, 02 Apr 2018 09:15:58 GMT
Connection: keep-alive
ETag: "5ac1f4ce-255e"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text, with very long lines (9172)
Size:   9566
Md5:    81b2be18696c4dfe620f7b6d0d75a566
Sha1:   0c3cd7bdf58a65b07e17be39cfe4e386571bb4bd
Sha256: 120aaf6681ca6d34a40c559779f0a0038582a79fce1b868ff901c94d27c89c72

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /wp-content/plugins/woocommerce/assets/js/js-cookie/js.cookie.min.js?ver=2.1.4 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:41 GMT
Content-Length: 1846
Last-Modified: Mon, 02 Apr 2018 09:15:58 GMT
Connection: keep-alive
ETag: "5ac1f4ce-736"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text, with very long lines (1680)
Size:   1846
Md5:    943f6eb962c25bd965e0f0e5a284fcd0
Sha1:   b050a98ebaef01d7597bf8c1acb995c0ef3bcbd9
Sha256: 50de09b0bb8d0ac656aa9b3a1e4ef58a3f2d1abd734cad68b0e12191e9d215ea

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /wp-content/plugins/woocommerce/assets/js/frontend/woocommerce.min.js?ver=3.3.4 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:41 GMT
Content-Length: 562
Connection: keep-alive
X-Accel-Version: 0.01
Last-Modified: Mon, 02 Apr 2018 09:15:58 GMT
ETag: "232-568da09ae98a6"
Accept-Ranges: bytes
X-Powered-By: PleskLin


--- Additional Info ---
Magic:  ASCII text, with very long lines (562), with no line terminators
Size:   562
Md5:    765234021a972dcbdd5ef011a4870b28
Sha1:   49c7cef1785f857aaca8d1757ac7aa26041c635d
Sha256: c6361a648d15fdf9cad312750da2568bd07a34a58e2ee1e1cf6b50d878e11a08

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /wp-content/themes/uncode/library/js/init.js?ver=178556683 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:41 GMT
Content-Length: 108233
Last-Modified: Wed, 03 Jan 2018 13:20:41 GMT
Connection: keep-alive
ETag: "5a4cd8a9-1a6c9"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  Unicode text, UTF-8 text, with very long lines (442)
Size:   108233
Md5:    5a079a5378b438c7a5e103b274a15260
Sha1:   d4d1d5885d760cdc124ec96f00712b341c90a8ec
Sha256: 4c5b1b6637f39a8b0f2525fd5d33c59d64fd3cf1a5ce2fa042c58a08741cb970

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /wp-content/plugins/woocommerce/assets/js/frontend/cart-fragments.min.js?ver=3.3.4 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:41 GMT
Content-Length: 2568
Last-Modified: Mon, 02 Apr 2018 09:15:58 GMT
Connection: keep-alive
ETag: "5ac1f4ce-a08"
X-Powered-By: PleskLin
Accept-Ranges: bytes


--- Additional Info ---
Magic:  ASCII text, with very long lines (2568), with no line terminators
Size:   2568
Md5:    8b2fd88b3f924f11f2d712522dcf3af0
Sha1:   959b771c513334b831506fe213aabebc9ced0b51
Sha256: ee3398bdd77ecef0ed98349221612af04335c2c0a4c372bd84682fabc0d23068

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /wp-content/plugins/gallery-by-supsystic/src/GridGallery/Colorbox/jquery-colorbox/i18n/jquery.colorbox-es.js?ver=1.11.3 HTTP/1.1 
Host: mindfuldog.es
                                        
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
Connection: keep-alive
Referer: http://mindfuldog.es/
Cookie: PHPSESSID=pgabo8md10s2mn06noe71a31ke

                                         
                                         185.209.60.23
HTTP/1.1 200 OK
Content-Type: application/javascript
                                        
Server: nginx
Date: Wed, 28 Sep 2022 02:25:41 GMT
Content-Length: 347
Connection: keep-alive
X-Accel-Version: 0.01
Last-Modified: Mon, 30 Apr 2018 10:19:10 GMT
ETag: "15b-56b0e2f458491"
Accept-Ranges: bytes
X-Powered-By: PleskLin


--- Additional Info ---
Magic:  ASCII text, with CRLF line terminators
Size:   347
Md5:    0645b374e6426e2e064f4c0ed4e58353
Sha1:   56d0f1c28e78aef12240521b2f6b47859559cf25
Sha256: 1bbeacdd72d88488c0d38c40f23ca9c58484a4da36628f7d58fceef80dcca5b1

Alerts:
  Blocklists:
    - fortinet: Phishing
                                        
                                            GET /af/053fc9/00000000000000003b9af1e4/27/l?primer=7cdcb44be4a7db8877ffa5c0007b8dd865b3bbc383831fe2ea177f62257a9191&fvd=n7&v=3 HTTP/1.1 
Host: use.typekit.net
                                        
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: http://mindfuldog.es
Connection: keep-alive
Referer: https://use.typekit.net/
Sec-Fetch-Dest: font
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site
TE: trailers

                                         
                                         23.36.76.122
HTTP/2 200 OK
content-type: application/font-woff2
                                        
server: nginx
content-length: 40472
etag: "bccc83ecab24faeba135395feebdc7112041b9e4"
timing-allow-origin: *
access-control-allow-origin: *
cross-origin-resource-policy: cross-origin
cache-control: public, max-age=31536000
date: Wed, 28 Sep 2022 02:25:41 GMT
X-Firefox-Spdy: h2


--- Additional Info ---
Magic:  Web Open Font Format (Version 2), TrueType, length 40472, version 1.0\012- data
Size:   40472
Md5:    3f7b543460959e6f6d480a601a61ac7a
Sha1:   eecb3c0419b7b15dacef8655f1598e41831e87fc
Sha256: ccd3b65aadf5132d22e827dedb58c06a0a808d2a2facfdcf7be6f773dbfa7c48
                                        
                                            GET /s/poppins/v20/pxiByp8kv8JHgFVrLEj6Z1xlFQ.woff2 HTTP/1.1 
Host: fonts.gstatic.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: http://mindfuldog.es
Connection: keep-alive
Referer: http://fonts.googleapis.com/

                                         
                                         142.250.74.163
HTTP/1.1 200 OK
Content-Type: font/woff2
                                        
Accept-Ranges: bytes
Access-Control-Allow-Origin: *
Content-Security-Policy-Report-Only: require-trusted-types-for 'script'; report-uri https://csp.withgoogle.com/csp/apps-themes
Cross-Origin-Resource-Policy: cross-origin
Cross-Origin-Opener-Policy: same-origin; report-to="apps-themes"
Report-To: {"group":"apps-themes","max_age":2592000,"endpoints":[{"url":"https://csp.withgoogle.com/csp/report-to/apps-themes"}]}
Timing-Allow-Origin: *
Content-Length: 8000
X-Content-Type-Options: nosniff
Server: sffe
X-XSS-Protection: 0
Date: Wed, 21 Sep 2022 23:32:43 GMT
Expires: Thu, 21 Sep 2023 23:32:43 GMT
Cache-Control: public, max-age=31536000
Age: 528778
Last-Modified: Wed, 27 Apr 2022 16:59:07 GMT


--- Additional Info ---
Magic:  Web Open Font Format (Version 2), TrueType, length 8000, version 1.0\012- data
Size:   8000
Md5:    72993dddf88a63e8f226656f7de88e57
Sha1:   179f97ec0275f09603a8db94d4380eb584d81cd5
Sha256: f4e80d9dfd374d02989b87a27b5ed4cb78fbb177c27f1478e9a8b0afb7513149
                                        
                                            GET /s/poppins/v20/pxiEyp8kv8JHgFVrJJfecg.woff2 HTTP/1.1 
Host: fonts.gstatic.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: http://mindfuldog.es
Connection: keep-alive
Referer: http://fonts.googleapis.com/

                                         
                                         142.250.74.163
HTTP/1.1 200 OK
Content-Type: font/woff2
                                        
Accept-Ranges: bytes
Access-Control-Allow-Origin: *
Content-Security-Policy-Report-Only: require-trusted-types-for 'script'; report-uri https://csp.withgoogle.com/csp/apps-themes
Cross-Origin-Resource-Policy: cross-origin
Cross-Origin-Opener-Policy: same-origin; report-to="apps-themes"
Report-To: {"group":"apps-themes","max_age":2592000,"endpoints":[{"url":"https://csp.withgoogle.com/csp/report-to/apps-themes"}]}
Timing-Allow-Origin: *
Content-Length: 7884
X-Content-Type-Options: nosniff
Server: sffe
X-XSS-Protection: 0
Date: Thu, 22 Sep 2022 00:34:17 GMT
Expires: Fri, 22 Sep 2023 00:34:17 GMT
Cache-Control: public, max-age=31536000
Age: 525084
Last-Modified: Wed, 27 Apr 2022 17:03:52 GMT


--- Additional Info ---
Magic:  Web Open Font Format (Version 2), TrueType, length 7884, version 1.0\012- data
Size:   7884
Md5:    9212f6f9860f9fc6c69b02fedf6db8c3
Sha1:   ac6d71b4d5fdd2b3dabc9a06ff6c001e4251da0b
Sha256: 7d93459d86585bfcdbb7e0376056226adb25821ee54b96236fe2123e9560929f
                                        
                                            GET /s/sourcesanspro/v21/6xK3dSBYKcSV-LCoeQqfX1RYOo3qOK7l.woff2 HTTP/1.1 
Host: fonts.gstatic.com