@charset "UTF-8";

/*!
 * animate.css -http://daneden.me/animate
 * Version - 3.5.2
 * Licensed under the MIT license - http://opensource.org/licenses/MIT
 *
 * Copyright (c) 2017 Daniel Eden
 */

.animatedslick {
  animation-duration: 1s;
  animation-fill-mode: both;
}

/*.slick-active .animated{
  animation-duration: 1s;
  animation-fill-mode: both;
}*/

.animatedslick.infinite {
  animation-iteration-count: infinite;
}

.animatedslick.hinge {
  animation-duration: 2s;
}

.animatedslick.flipOutX,
.animatedslick.flipOutY,
.animatedslick.bounceIn,
.animatedslick.bounceOut {
  animation-duration: .75s;
}

@keyframes slickbounce {
  from, 20%, 53%, 80%, to {
    animation-timing-function: cubic-bezier(0.215, 0.610, 0.355, 1.000);
    transform: translate3d(0,0,0);
  }

  40%, 43% {
    animation-timing-function: cubic-bezier(0.755, 0.050, 0.855, 0.060);
    transform: translate3d(0, -30px, 0);
  }

  70% {
    animation-timing-function: cubic-bezier(0.755, 0.050, 0.855, 0.060);
    transform: translate3d(0, -15px, 0);
  }

  90% {
    transform: translate3d(0,-4px,0);
  }
}

.slick-current .bounce {
  animation-name: slickbounce;
  transform-origin: center bottom;
}

@keyframes slickflash {
  from, 50%, to {
    opacity: 1;
  }

  25%, 75% {
    opacity: 0;
  }
}

.slick-current .flash {
  animation-name: slickflash;
}

/* originally authored by Nick Pettit - https://github.com/nickpettit/glide */

@keyframes slickpulse {
  from {
    transform: scale3d(1, 1, 1);
  }

  50% {
    transform: scale3d(1.05, 1.05, 1.05);
  }

  to {
    transform: scale3d(1, 1, 1);
  }
}

.slick-current .pulse {
  animation-name: slickpulse;
}

@keyframes slickrubberBand {
  from {
    transform: scale3d(1, 1, 1);
  }

  30% {
    transform: scale3d(1.25, 0.75, 1);
  }

  40% {
    transform: scale3d(0.75, 1.25, 1);
  }

  50% {
    transform: scale3d(1.15, 0.85, 1);
  }

  65% {
    transform: scale3d(.95, 1.05, 1);
  }

  75% {
    transform: scale3d(1.05, .95, 1);
  }

  to {
    transform: scale3d(1, 1, 1);
  }
}

.slick-current .rubberBand {
  animation-name: slickrubberBand;
}

@keyframes slickshake {
  from, to {
    transform: translate3d(0, 0, 0);
  }

  10%, 30%, 50%, 70%, 90% {
    transform: translate3d(-10px, 0, 0);
  }

  20%, 40%, 60%, 80% {
    transform: translate3d(10px, 0, 0);
  }
}

.slick-current .shake {
  animation-name: slickshake;
}

@keyframes slickheadShake {
  0% {
    transform: translateX(0);
  }

  6.5% {
    transform: translateX(-6px) rotateY(-9deg);
  }

  18.5% {
    transform: translateX(5px) rotateY(7deg);
  }

  31.5% {
    transform: translateX(-3px) rotateY(-5deg);
  }

  43.5% {
    transform: translateX(2px) rotateY(3deg);
  }

  50% {
    transform: translateX(0);
  }
}

.slick-current .headShake {
  animation-timing-function: ease-in-out;
  animation-name: slickheadShake;
}

@keyframes slickswing {
  20% {
    transform: rotate3d(0, 0, 1, 15deg);
  }

  40% {
    transform: rotate3d(0, 0, 1, -10deg);
  }

  60% {
    transform: rotate3d(0, 0, 1, 5deg);
  }

  80% {
    transform: rotate3d(0, 0, 1, -5deg);
  }

  to {
    transform: rotate3d(0, 0, 1, 0deg);
  }
}

.slick-current .swing {
  transform-origin: top center;
  animation-name: slickswing;
}

@keyframes slicktada {
  from {
    transform: scale3d(1, 1, 1);
  }

  10%, 20% {
    transform: scale3d(.9, .9, .9) rotate3d(0, 0, 1, -3deg);
  }

  30%, 50%, 70%, 90% {
    transform: scale3d(1.1, 1.1, 1.1) rotate3d(0, 0, 1, 3deg);
  }

  40%, 60%, 80% {
    transform: scale3d(1.1, 1.1, 1.1) rotate3d(0, 0, 1, -3deg);
  }

  to {
    transform: scale3d(1, 1, 1);
  }
}

.slick-current .tada {
  animation-name: slicktada;
}

/* originally authored by Nick Pettit - https://github.com/nickpettit/glide */

@keyframes slickwobble {
  from {
    transform: none;
  }

  15% {
    transform: translate3d(-25%, 0, 0) rotate3d(0, 0, 1, -5deg);
  }

  30% {
    transform: translate3d(20%, 0, 0) rotate3d(0, 0, 1, 3deg);
  }

  45% {
    transform: translate3d(-15%, 0, 0) rotate3d(0, 0, 1, -3deg);
  }

  60% {
    transform: translate3d(10%, 0, 0) rotate3d(0, 0, 1, 2deg);
  }

  75% {
    transform: translate3d(-5%, 0, 0) rotate3d(0, 0, 1, -1deg);
  }

  to {
    transform: none;
  }
}

.slick-current .wobble {
  animation-name: slickwobble;
}

@keyframes slickjello {
  from, 11.1%, to {
    transform: none;
  }

  22.2% {
    transform: skewX(-12.5deg) skewY(-12.5deg);
  }

  33.3% {
    transform: skewX(6.25deg) skewY(6.25deg);
  }

  44.4% {
    transform: skewX(-3.125deg) skewY(-3.125deg);
  }

  55.5% {
    transform: skewX(1.5625deg) skewY(1.5625deg);
  }

  66.6% {
    transform: skewX(-0.78125deg) skewY(-0.78125deg);
  }

  77.7% {
    transform: skewX(0.390625deg) skewY(0.390625deg);
  }

  88.8% {
    transform: skewX(-0.1953125deg) skewY(-0.1953125deg);
  }
}

.slick-current .jello {
  animation-name: slickjello;
  transform-origin: center;
}

@keyframes slickbounceIn {
  from, 20%, 40%, 60%, 80%, to {
    animation-timing-function: cubic-bezier(0.215, 0.610, 0.355, 1.000);
  }

  0% {
    opacity: 0;
    transform: scale3d(.3, .3, .3);
  }

  20% {
    transform: scale3d(1.1, 1.1, 1.1);
  }

  40% {
    transform: scale3d(.9, .9, .9);
  }

  60% {
    opacity: 1;
    transform: scale3d(1.03, 1.03, 1.03);
  }

  80% {
    transform: scale3d(.97, .97, .97);
  }

  to {
    opacity: 1;
    transform: scale3d(1, 1, 1);
  }
}

.slick-current .bounceIn {
  animation-name: slickbounceIn;
}

@keyframes slickbounceInDown {
  from, 60%, 75%, 90%, to {
    animation-timing-function: cubic-bezier(0.215, 0.610, 0.355, 1.000);
  }

  0% {
    opacity: 0;
    transform: translate3d(0, -3000px, 0);
  }

  60% {
    opacity: 1;
    transform: translate3d(0, 25px, 0);
  }

  75% {
    transform: translate3d(0, -10px, 0);
  }

  90% {
    transform: translate3d(0, 5px, 0);
  }

  to {
    transform: none;
  }
}

.slick-current .bounceInDown {
  animation-name: slickbounceInDown;
}

@keyframes slickbounceInLeft {
  from, 60%, 75%, 90%, to {
    animation-timing-function: cubic-bezier(0.215, 0.610, 0.355, 1.000);
  }

  0% {
    opacity: 0;
    transform: translate3d(-3000px, 0, 0);
  }

  60% {
    opacity: 1;
    transform: translate3d(25px, 0, 0);
  }

  75% {
    transform: translate3d(-10px, 0, 0);
  }

  90% {
    transform: translate3d(5px, 0, 0);
  }

  to {
    transform: none;
  }
}

.slick-current .bounceInLeft {
  animation-name: slickbounceInLeft;
}

@keyframes slickbounceInRight {
  from, 60%, 75%, 90%, to {
    animation-timing-function: cubic-bezier(0.215, 0.610, 0.355, 1.000);
  }

  from {
    opacity: 0;
    transform: translate3d(4000px, 0, 0);
  }

  60% {
    opacity: 1;
    transform: translate3d(-25px, 0, 0);
  }

  75% {
    transform: translate3d(10px, 0, 0);
  }

  90% {
    transform: translate3d(-5px, 0, 0);
  }

  to {
    transform: none;
  }
}

.slick-current .bounceInRight {
  animation-name: slickbounceInRight;
}

@keyframes slickbounceInUp {
  from, 60%, 75%, 90%, to {
    animation-timing-function: cubic-bezier(0.215, 0.610, 0.355, 1.000);
  }

  from {
    opacity: 0;
    transform: translate3d(0, 3000px, 0);
  }

  60% {
    opacity: 1;
    transform: translate3d(0, -20px, 0);
  }

  75% {
    transform: translate3d(0, 10px, 0);
  }

  90% {
    transform: translate3d(0, -5px, 0);
  }

  to {
    transform: translate3d(0, 0, 0);
  }
}

.slick-current .bounceInUp {
  animation-name: slickbounceInUp;
}

@keyframes slickbounceOut {
  20% {
    transform: scale3d(.9, .9, .9);
  }

  50%, 55% {
    opacity: 1;
    transform: scale3d(1.1, 1.1, 1.1);
  }

  to {
    opacity: 0;
    transform: scale3d(.3, .3, .3);
  }
}

.slick-current .bounceOut {
  animation-name: slickbounceOut;
}

@keyframes slickbounceOutDown {
  20% {
    transform: translate3d(0, 10px, 0);
  }

  40%, 45% {
    opacity: 1;
    transform: translate3d(0, -20px, 0);
  }

  to {
    opacity: 0;
    transform: translate3d(0, 2000px, 0);
  }
}

.slick-current .bounceOutDown {
  animation-name: slickbounceOutDown;
}

@keyframes slickbounceOutLeft {
  20% {
    opacity: 1;
    transform: translate3d(20px, 0, 0);
  }

  to {
    opacity: 0;
    transform: translate3d(-2000px, 0, 0);
  }
}

.slick-current .bounceOutLeft {
  animation-name: slickbounceOutLeft;
}

@keyframes slickbounceOutRight {
  20% {
    opacity: 1;
    transform: translate3d(-20px, 0, 0);
  }

  to {
    opacity: 0;
    transform: translate3d(2000px, 0, 0);
  }
}

.slick-current .bounceOutRight {
  animation-name: slickbounceOutRight;
}

@keyframes slickbounceOutUp {
  20% {
    transform: translate3d(0, -10px, 0);
  }

  40%, 45% {
    opacity: 1;
    transform: translate3d(0, 20px, 0);
  }

  to {
    opacity: 0;
    transform: translate3d(0, -2000px, 0);
  }
}

.slick-current .bounceOutUp {
  animation-name: slickbounceOutUp;
}

@keyframes slickfadeIn {
  from {
    opacity: 0;
  }

  to {
    opacity: 1;
  }
}

.slick-current .fadeIn {
  animation-name: slickfadeIn;
}

@keyframes slickfadeInDown {
  from {
    opacity: 0;
    transform: translate3d(0, -200%, 0);
  }

  to {
    opacity: 1;
    transform: none;
  }
}

.slick-current .fadeInDown {
  animation-name: slickfadeInDown;
}

@keyframes slickfadeInDownBig {
  from {
    opacity: 0;
    transform: translate3d(0, -3000px, 0);
  }

  to {
    opacity: 1;
    transform: none;
  }
}

.slick-current .fadeInDownBig {
  animation-name: slickfadeInDownBig;
}

@keyframes slickfadeInLeft {
  from {
    opacity: 0;
    transform: translate3d(-200%, 0, 0);
  }

  to {
    opacity: 1;
    transform: none;
  }
}

.slick-current .fadeInLeft {
  animation-name: slickfadeInLeft;
}

@keyframes slickfadeInLeftBig {
  from {
    opacity: 0;
    transform: translate3d(-2000px, 0, 0);
  }

  to {
    opacity: 1;
    transform: none;
  }
}

.slick-current .fadeInLeftBig {
  animation-name: slickfadeInLeftBig;
}

@keyframes slickfadeInRight {
  from {
    opacity: 0;
    transform: translate3d(200%, 0, 0);
  }

  to {
    opacity: 1;
    transform: none;
  }
}

.slick-current .fadeInRight {
  animation-name: slickfadeInRight;
}

@keyframes slickfadeInRightBig {
  from {
    opacity: 0;
    transform: translate3d(3000px, 0, 0);
  }

  to {
    opacity: 1;
    transform: none;
  }
}

.slick-current .fadeInRightBig {
  animation-name: slickfadeInRightBig;
}

@keyframes slickfadeInUp {
  from {
    opacity: 0;
    transform: translate3d(0, 200%, 0);
  }

  to {
    opacity: 1;
    transform: none;
  }
}

.slick-current .fadeInUp {
  animation-name: slickfadeInUp;
}

@keyframes slickfadeInUpBig {
  from {
    opacity: 0;
    transform: translate3d(0, 2000px, 0);
  }

  to {
    opacity: 1;
    transform: none;
  }
}

.slick-current .fadeInUpBig {
  animation-name: slickfadeInUpBig;
}

@keyframes slickfadeOut {
  from {
    opacity: 1;
  }

  to {
    opacity: 0;
  }
}

.slick-current .fadeOut {
  animation-name: slickfadeOut;
}

@keyframes slickfadeOutDown {
  from {
    opacity: 1;
  }

  to {
    opacity: 0;
    transform: translate3d(0, 100%, 0);
  }
}

.slick-current .fadeOutDown {
  animation-name: slickfadeOutDown;
}

@keyframes slickfadeOutDownBig {
  from {
    opacity: 1;
  }

  to {
    opacity: 0;
    transform: translate3d(0, 2000px, 0);
  }
}

.slick-current .fadeOutDownBig {
  animation-name: slickfadeOutDownBig;
}

@keyframes slickfadeOutLeft {
  from {
    opacity: 1;
  }

  to {
    opacity: 0;
    transform: translate3d(-100%, 0, 0);
  }
}

.slick-current .fadeOutLeft {
  animation-name: slickfadeOutLeft;
}

@keyframes slickfadeOutLeftBig {
  from {
    opacity: 1;
  }

  to {
    opacity: 0;
    transform: translate3d(-2000px, 0, 0);
  }
}

.slick-current .fadeOutLeftBig {
  animation-name: slickfadeOutLeftBig;
}

@keyframes slickfadeOutRight {
  from {
    opacity: 1;
  }

  to {
    opacity: 0;
    transform: translate3d(100%, 0, 0);
  }
}

.slick-current .fadeOutRight {
  animation-name: slickfadeOutRight;
}

@keyframes slickfadeOutRightBig {
  from {
    opacity: 1;
  }

  to {
    opacity: 0;
    transform: translate3d(2000px, 0, 0);
  }
}

.slick-current .fadeOutRightBig {
  animation-name: slickfadeOutRightBig;
}

@keyframes slickfadeOutUp {
  from {
    opacity: 1;
  }

  to {
    opacity: 0;
    transform: translate3d(0, -100%, 0);
  }
}

.slick-current .fadeOutUp {
  animation-name: slickfadeOutUp;
}

@keyframes slickfadeOutUpBig {
  from {
    opacity: 1;
  }

  to {
    opacity: 0;
    transform: translate3d(0, -2000px, 0);
  }
}

.slick-current .fadeOutUpBig {
  animation-name: slickfadeOutUpBig;
}

@keyframes slickflip {
  from {
    transform: perspective(400px) rotate3d(0, 1, 0, -360deg);
    animation-timing-function: ease-out;
  }

  40% {
    transform: perspective(400px) translate3d(0, 0, 150px) rotate3d(0, 1, 0, -190deg);
    animation-timing-function: ease-out;
  }

  50% {
    transform: perspective(400px) translate3d(0, 0, 150px) rotate3d(0, 1, 0, -170deg);
    animation-timing-function: ease-in;
  }

  80% {
    transform: perspective(400px) scale3d(.95, .95, .95);
    animation-timing-function: ease-in;
  }

  to {
    transform: perspective(400px);
    animation-timing-function: ease-in;
  }
}

.slick-current .animatedslick.flip {
  -webkit-backface-visibility: visible;
  backface-visibility: visible;
  animation-name: slickflip;
}

@keyframes slickflipInX {
  from {
    transform: perspective(400px) rotate3d(1, 0, 0, 90deg);
    animation-timing-function: ease-in;
    opacity: 0;
  }

  40% {
    transform: perspective(400px) rotate3d(1, 0, 0, -20deg);
    animation-timing-function: ease-in;
  }

  60% {
    transform: perspective(400px) rotate3d(1, 0, 0, 10deg);
    opacity: 1;
  }

  80% {
    transform: perspective(400px) rotate3d(1, 0, 0, -5deg);
  }

  to {
    transform: perspective(400px);
  }
}

.slick-current .flipInX {
  -webkit-backface-visibility: visible !important;
  backface-visibility: visible !important;
  animation-name: slickflipInX;
}

@keyframes slickflipInY {
  from {
    transform: perspective(400px) rotate3d(0, 1, 0, 90deg);
    animation-timing-function: ease-in;
    opacity: 0;
  }

  40% {
    transform: perspective(400px) rotate3d(0, 1, 0, -20deg);
    animation-timing-function: ease-in;
  }

  60% {
    transform: perspective(400px) rotate3d(0, 1, 0, 10deg);
    opacity: 1;
  }

  80% {
    transform: perspective(400px) rotate3d(0, 1, 0, -5deg);
  }

  to {
    transform: perspective(400px);
  }
}

.slick-current .flipInY {
  -webkit-backface-visibility: visible !important;
  backface-visibility: visible !important;
  animation-name: slickflipInY;
}

@keyframes slickflipOutX {
  from {
    transform: perspective(400px);
  }

  30% {
    transform: perspective(400px) rotate3d(1, 0, 0, -20deg);
    opacity: 1;
  }

  to {
    transform: perspective(400px) rotate3d(1, 0, 0, 90deg);
    opacity: 0;
  }
}

.slick-current .flipOutX {
  animation-name: slickflipOutX;
  -webkit-backface-visibility: visible !important;
  backface-visibility: visible !important;
}

@keyframes slickflipOutY {
  from {
    transform: perspective(400px);
  }

  30% {
    transform: perspective(400px) rotate3d(0, 1, 0, -15deg);
    opacity: 1;
  }

  to {
    transform: perspective(400px) rotate3d(0, 1, 0, 90deg);
    opacity: 0;
  }
}

.slick-current .flipOutY {
  -webkit-backface-visibility: visible !important;
  backface-visibility: visible !important;
  animation-name: slickflipOutY;
}

@keyframes slicklightSpeedIn {
  from {
    transform: translate3d(100%, 0, 0) skewX(-30deg);
    opacity: 0;
  }

  60% {
    transform: skewX(20deg);
    opacity: 1;
  }

  80% {
    transform: skewX(-5deg);
    opacity: 1;
  }

  to {
    transform: none;
    opacity: 1;
  }
}

.slick-current .lightSpeedIn {
  animation-name: slicklightSpeedIn;
  animation-timing-function: ease-out;
}

@keyframes slicklightSpeedOut {
  from {
    opacity: 1;
  }

  to {
    transform: translate3d(100%, 0, 0) skewX(30deg);
    opacity: 0;
  }
}

.slick-current .lightSpeedOut {
  animation-name: slicklightSpeedOut;
  animation-timing-function: ease-in;
}

@keyframes slickrotateIn {
  from {
    transform-origin: center;
    transform: rotate3d(0, 0, 1, -200deg);
    opacity: 0;
  }

  to {
    transform-origin: center;
    transform: none;
    opacity: 1;
  }
}

.slick-current .rotateIn {
  animation-name: slickrotateIn;
}

@keyframes slickrotateInDownLeft {
  from {
    transform-origin: left bottom;
    transform: rotate3d(0, 0, 1, -45deg);
    opacity: 0;
  }

  to {
    transform-origin: left bottom;
    transform: none;
    opacity: 1;
  }
}

.slick-current .rotateInDownLeft {
  animation-name: slickrotateInDownLeft;
}

@keyframes slickrotateInDownRight {
  from {
    transform-origin: right bottom;
    transform: rotate3d(0, 0, 1, 45deg);
    opacity: 0;
  }

  to {
    transform-origin: right bottom;
    transform: none;
    opacity: 1;
  }
}

.slick-current .rotateInDownRight {
  animation-name: slickrotateInDownRight;
}

@keyframes slickrotateInUpLeft {
  from {
    transform-origin: left bottom;
    transform: rotate3d(0, 0, 1, 45deg);
    opacity: 0;
  }

  to {
    transform-origin: left bottom;
    transform: none;
    opacity: 1;
  }
}

.slick-current .rotateInUpLeft {
  animation-name: slickrotateInUpLeft;
}

@keyframes slickrotateInUpRight {
  from {
    transform-origin: right bottom;
    transform: rotate3d(0, 0, 1, -90deg);
    opacity: 0;
  }

  to {
    transform-origin: right bottom;
    transform: none;
    opacity: 1;
  }
}

.slick-current .rotateInUpRight {
  animation-name: slickrotateInUpRight;
}

@keyframes slickrotateOut {
  from {
    transform-origin: center;
    opacity: 1;
  }

  to {
    transform-origin: center;
    transform: rotate3d(0, 0, 1, 200deg);
    opacity: 0;
  }
}

.slick-current .rotateOut {
  animation-name: slickrotateOut;
}

@keyframes slickrotateOutDownLeft {
  from {
    transform-origin: left bottom;
    opacity: 1;
  }

  to {
    transform-origin: left bottom;
    transform: rotate3d(0, 0, 1, 45deg);
    opacity: 0;
  }
}

.slick-current .rotateOutDownLeft {
  animation-name: slickrotateOutDownLeft;
}

@keyframes slickrotateOutDownRight {
  from {
    transform-origin: right bottom;
    opacity: 1;
  }

  to {
    transform-origin: right bottom;
    transform: rotate3d(0, 0, 1, -45deg);
    opacity: 0;
  }
}

.slick-current .rotateOutDownRight {
  animation-name: slickrotateOutDownRight;
}

@keyframes slickrotateOutUpLeft {
  from {
    transform-origin: left bottom;
    opacity: 1;
  }

  to {
    transform-origin: left bottom;
    transform: rotate3d(0, 0, 1, -45deg);
    opacity: 0;
  }
}

.slick-current .rotateOutUpLeft {
  animation-name: slickrotateOutUpLeft;
}

@keyframes slickrotateOutUpRight {
  from {
    transform-origin: right bottom;
    opacity: 1;
  }

  to {
    transform-origin: right bottom;
    transform: rotate3d(0, 0, 1, 90deg);
    opacity: 0;
  }
}

.slick-current .rotateOutUpRight {
  animation-name: slickrotateOutUpRight;
}

@keyframes slickhinge {
  0% {
    transform-origin: top left;
    animation-timing-function: ease-in-out;
  }

  20%, 60% {
    transform: rotate3d(0, 0, 1, 80deg);
    transform-origin: top left;
    animation-timing-function: ease-in-out;
  }

  40%, 80% {
    transform: rotate3d(0, 0, 1, 60deg);
    transform-origin: top left;
    animation-timing-function: ease-in-out;
    opacity: 1;
  }

  to {
    transform: translate3d(0, 700px, 0);
    opacity: 0;
  }
}

.slick-current .hinge {
  animation-name: slickhinge;
}

@keyframes slickjackInTheBox {
  from {
    opacity: 0;
    transform: scale(0.1) rotate(30deg);
    transform-origin: center bottom;
  }

  50% {
    transform: rotate(-10deg);
  }

  70% {
    transform: rotate(3deg);
  }

  to {
    opacity: 1;
    transform: scale(1);
  }
}

.slick-current .jackInTheBox {
  animation-name: slickjackInTheBox;
}

/* originally authored by Nick Pettit - https://github.com/nickpettit/glide */

@keyframes slickrollIn {
  from {
    opacity: 0;
    transform: translate3d(-100%, 0, 0) rotate3d(0, 0, 1, -120deg);
  }

  to {
    opacity: 1;
    transform: none;
  }
}

.slick-current .rollIn {
  animation-name: slickrollIn;
}

/* originally authored by Nick Pettit - https://github.com/nickpettit/glide */

@keyframes slickrollOut {
  from {
    opacity: 1;
  }

  to {
    opacity: 0;
    transform: translate3d(100%, 0, 0) rotate3d(0, 0, 1, 120deg);
  }
}

.slick-current .rollOut {
  animation-name: slickrollOut;
}

@keyframes slickzoomIn {
  from {
    opacity: 0;
    transform: scale3d(.1, .1, .1);
  }

  50% {
    opacity: 1;
  }
}

.slick-current .zoomIn {
  animation-name: slickzoomIn;
}

@keyframes slickzoomInDown {
  from {
    opacity: 0;
    transform: scale3d(.1, .1, .1) translate3d(0, -1000px, 0);
    animation-timing-function: cubic-bezier(0.550, 0.055, 0.675, 0.190);
  }

  60% {
    opacity: 1;
    transform: scale3d(.475, .475, .475) translate3d(0, 60px, 0);
    animation-timing-function: cubic-bezier(0.175, 0.885, 0.320, 1);
  }
}

.slick-current .zoomInDown {
  animation-name: slickzoomInDown;
}

@keyframes slickzoomInLeft {
  from {
    opacity: 0;
    transform: scale3d(.1, .1, .1) translate3d(-1000px, 0, 0);
    animation-timing-function: cubic-bezier(0.550, 0.055, 0.675, 0.190);
  }

  60% {
    opacity: 1;
    transform: scale3d(.475, .475, .475) translate3d(10px, 0, 0);
    animation-timing-function: cubic-bezier(0.175, 0.885, 0.320, 1);
  }
}

.slick-current .zoomInLeft {
  animation-name: slickzoomInLeft;
}

@keyframes slickzoomInRight {
  from {
    opacity: 0;
    transform: scale3d(.1, .1, .1) translate3d(1000px, 0, 0);
    animation-timing-function: cubic-bezier(0.550, 0.055, 0.675, 0.190);
  }

  60% {
    opacity: 1;
    transform: scale3d(.475, .475, .475) translate3d(-10px, 0, 0);
    animation-timing-function: cubic-bezier(0.175, 0.885, 0.320, 1);
  }
}

.slick-current .zoomInRight {
  animation-name: slickzoomInRight;
}

@keyframes slickzoomInUp {
  from {
    opacity: 0;
    transform: scale3d(.1, .1, .1) translate3d(0, 1000px, 0);
    animation-timing-function: cubic-bezier(0.550, 0.055, 0.675, 0.190);
  }

  60% {
    opacity: 1;
    transform: scale3d(.475, .475, .475) translate3d(0, -60px, 0);
    animation-timing-function: cubic-bezier(0.175, 0.885, 0.320, 1);
  }
}

.slick-current .zoomInUp {
  animation-name: slickzoomInUp;
}

@keyframes slickzoomOut {
  from {
    opacity: 1;
  }

  50% {
    opacity: 0;
    transform: scale3d(.3, .3, .3);
  }

  to {
    opacity: 0;
  }
}

.slick-current .zoomOut {
  animation-name: slickzoomOut;
}

@keyframes slickzoomOutDown {
  40% {
    opacity: 1;
    transform: scale3d(.475, .475, .475) translate3d(0, -60px, 0);
    animation-timing-function: cubic-bezier(0.550, 0.055, 0.675, 0.190);
  }

  to {
    opacity: 0;
    transform: scale3d(.1, .1, .1) translate3d(0, 2000px, 0);
    transform-origin: center bottom;
    animation-timing-function: cubic-bezier(0.175, 0.885, 0.320, 1);
  }
}

.slick-current .zoomOutDown {
  animation-name: slickzoomOutDown;
}

@keyframes slickzoomOutLeft {
  40% {
    opacity: 1;
    transform: scale3d(.475, .475, .475) translate3d(42px, 0, 0);
  }

  to {
    opacity: 0;
    transform: scale(.1) translate3d(-2000px, 0, 0);
    transform-origin: left center;
  }
}

.slick-current .zoomOutLeft {
  animation-name: slickzoomOutLeft;
}

@keyframes slickzoomOutRight {
  40% {
    opacity: 1;
    transform: scale3d(.475, .475, .475) translate3d(-42px, 0, 0);
  }

  to {
    opacity: 0;
    transform: scale(.1) translate3d(2000px, 0, 0);
    transform-origin: right center;
  }
}

.slick-current .zoomOutRight {
  animation-name: slickzoomOutRight;
}

@keyframes slickzoomOutUp {
  40% {
    opacity: 1;
    transform: scale3d(.475, .475, .475) translate3d(0, 60px, 0);
    animation-timing-function: cubic-bezier(0.550, 0.055, 0.675, 0.190);
  }

  to {
    opacity: 0;
    transform: scale3d(.1, .1, .1) translate3d(0, -2000px, 0);
    transform-origin: center bottom;
    animation-timing-function: cubic-bezier(0.175, 0.885, 0.320, 1);
  }
}

.slick-current .zoomOutUp {
  animation-name: slickzoomOutUp;
}

@keyframes slickslideInDown {
  from {
    transform: translate3d(0, -250%, 0);
    visibility: visible;
  }

  to {
    transform: translate3d(0, 0, 0);
  }
}

.slick-current .slideInDown {
  animation-name: slickslideInDown;
}

@keyframes slickslideInLeft {
  from {
    transform: translate3d(-450%, 0, 0);
    visibility: visible;
  }

  to {
    transform: translate3d(0, 0, 0);
  }
}

.slick-current .slideInLeft {
  animation-name: slickslideInLeft;
}

@keyframes slickslideInRight {
  from {
    transform: translate3d(400%, 0, 0);
    visibility: visible;
  }

  to {
    transform: translate3d(0, 0, 0);
  }
}

.slick-current .slideInRight {
  animation-name: slickslideInRight;
}

@keyframes slickslideInUp {
  from {
    transform: translate3d(0, 100%, 0);
    visibility: visible;
  }

  to {
    transform: translate3d(0, 0, 0);
  }
}

.slick-current .slideInUp {
  animation-name: slickslideInUp;
}

@keyframes slickslideOutDown {
  from {
    transform: translate3d(0, 0, 0);
  }

  to {
    visibility: hidden;
    transform: translate3d(0, 100%, 0);
  }
}

.slick-current .slideOutDown {
  animation-name: slickslideOutDown;
}

@keyframes slideOutLeft {
  from {
    transform: translate3d(0, 0, 0);
  }

  to {
    visibility: hidden;
    transform: translate3d(-250%, 0, 0);
  }
}

.slick-current .slideOutLeft {
  animation-name: slickslideOutLeft;
}

@keyframes slickslideOutRight {
  from {
    transform: translate3d(0, 0, 0);
  }

  to {
    visibility: hidden;
    transform: translate3d(100%, 0, 0);
  }
}

.slick-current .slideOutRight {
  animation-name: slickslideOutRight;
}

@keyframes slickslideOutUp {
  from {
    transform: translate3d(0, 0, 0);
  }

  to {
    visibility: hidden;
    transform: translate3d(0, -100%, 0);
  }
}

.slick-current .slideOutUp {
  animation-name: slickslideOutUp;
}