/** @define Test */

/**
 * The 'describe' CSS counter
 */

.Test {
  counter-reset: test-describe;
}

.Test-describe::before {
  content: counter(test-describe);
  counter-increment: test-describe;
}

/**
 * The 'it' CSS counter
 */

.Test-describe {
  counter-reset: test-it;
}

.Test-it::before {
  content: counter(test-describe) "." counter(test-it);
  counter-increment: test-it;
}

/**
 * The test title
 */

.Test-title {
  background: #eee;
  color: #999;
  font-family: sans-serif;
  font-size: 2em;
  margin: 20px 0;
  padding: 20px;
}

/**
 * The test description and expectation titles
 */

.Test-describe,
.Test-it {
  background: #eee;
  border-left: 5px solid #666;
  color: #666;
  font-family: sans-serif;
  font-weight: bold;
  margin: 20px 0;
  padding: 0.75em 20px;
}

.Test-describe {
  font-size: 1.5em;
  margin: 60px 0 20px;
}

/**
 * The counter styles
 */

.Test-describe::before,
.Test-it::before {
  color: #999;
  display: inline-block;
  margin-right: 10px;
  min-width: 30px;
  text-transform: uppercase;
}

/**
 * @define utilities
 * Sizing utilities
 */

/* Proportional widths
   ========================================================================== */

/**
 * Specify the proportional width of an object.
 * Intentional redundancy build into each set of unit classes.
 * Supports: 2, 3, 4, 5, 6, 8, 10, 12 part
 *
 * 1. Use `flex-basis: auto` with a width to avoid box-sizing bug in IE10/11
 *    http://git.io/vllMD
 */

/* postcss-bem-linter: ignore */

[class*="u-size"] {
  -webkit-flex-basis: auto !important;
      -ms-flex-preferred-size: auto !important;
          flex-basis: auto !important; /* 1 */
}

.u-size1of12 {
  width: 8.33333% !important;
}

.u-size1of10 {
  width: 10% !important;
}

.u-size1of8 {
  width: 12.5% !important;
}

.u-size1of6,
.u-size2of12 {
  width: 16.66667% !important;
}

.u-size1of5,
.u-size2of10 {
  width: 20% !important;
}

.u-size1of4,
.u-size2of8,
.u-size3of12 {
  width: 25% !important;
}

.u-size3of10 {
  width: 30% !important;
}

.u-size1of3,
.u-size2of6,
.u-size4of12 {
  width: 33.33333% !important;
}

.u-size3of8 {
  width: 37.5% !important;
}

.u-size2of5,
.u-size4of10 {
  width: 40% !important;
}

.u-size5of12 {
  width: 41.66667% !important;
}

.u-size1of2,
.u-size2of4,
.u-size3of6,
.u-size4of8,
.u-size5of10,
.u-size6of12 {
  width: 50% !important;
}

.u-size7of12 {
  width: 58.33333% !important;
}

.u-size3of5,
.u-size6of10 {
  width: 60% !important;
}

.u-size5of8 {
  width: 62.5% !important;
}

.u-size2of3,
.u-size4of6,
.u-size8of12 {
  width: 66.66667% !important;
}

.u-size7of10 {
  width: 70% !important;
}

.u-size3of4,
.u-size6of8,
.u-size9of12 {
  width: 75% !important;
}

.u-size4of5,
.u-size8of10 {
  width: 80% !important;
}

.u-size5of6,
.u-size10of12 {
  width: 83.33333% !important;
}

.u-size7of8 {
  width: 87.5% !important;
}

.u-size9of10 {
  width: 90% !important;
}

.u-size11of12 {
  width: 91.66667% !important;
}

/* Intrinsic widths
   ========================================================================== */

/**
 * Make an element fill the remaining space.
 *
 * 1. Be explicit to work around IE10 bug with shorthand flex
 *    http://git.io/vllC7
 * 2. IE10 ignores previous `flex-basis` value. Setting again here fixes
 *    http://git.io/vllMt
 */

.u-sizeFill {
  -webkit-box-flex: 1 !important;
  -webkit-flex: 1 1 0% !important;
      -ms-flex: 1 1 0% !important;
          flex: 1 1 0% !important; /* 1 */
  -webkit-flex-basis: 0% !important;
      -ms-flex-preferred-size: 0% !important;
          flex-basis: 0% !important; /* 2 */
}

/**
 * An alternative method to make an element fill the remaining space.
 * Distributes space based on the initial width and height of the element
 *
 * http://www.w3.org/TR/css-flexbox/images/rel-vs-abs-flex.svg
 */

.u-sizeFillAlt {
  -webkit-box-flex: 1 !important;
  -webkit-flex: 1 1 auto !important;
      -ms-flex: 1 1 auto !important;
          flex: 1 1 auto !important;
  -webkit-flex-basis: auto !important;
      -ms-flex-preferred-size: auto !important;
          flex-basis: auto !important;
}

/**
 * Make an element the width of its parent.
 */

.u-sizeFull {
  box-sizing: border-box !important;
  display: block !important;
  width: 100% !important;
}

/**
 * @define utilities
 * Size: breakpoint 1 (small)
 */

@media (min-width:320px) and (max-width:640px) {

  /* Proportional widths: breakpoint 1 (small)
     ======================================================================== */

  /**
   * Specify the proportional width of an object.
   * Intentional redundancy build into each set of unit classes.
   * Supports: 2, 3, 4, 5, 6, 8, 10, 12 part
   *
   * 1. Use `flex-basis: auto` with a width to avoid box-sizing bug in IE10/11
   *    http://git.io/vllMD
   */

  /* postcss-bem-linter: ignore */

  [class*="u-sm-size"] {
    -webkit-flex-basis: auto !important;
        -ms-flex-preferred-size: auto !important;
            flex-basis: auto !important; /* 1 */
  }

  .u-sm-size1of12 {
    width: 8.33333% !important;
  }

  .u-sm-size1of10 {
    width: 10% !important;
  }

  .u-sm-size1of8 {
    width: 12.5% !important;
  }

  .u-sm-size1of6,
  .u-sm-size2of12 {
    width: 16.66667% !important;
  }

  .u-sm-size1of5,
  .u-sm-size2of10 {
    width: 20% !important;
  }

  .u-sm-size1of4,
  .u-sm-size2of8,
  .u-sm-size3of12 {
    width: 25% !important;
  }

  .u-sm-size3of10 {
    width: 30% !important;
  }

  .u-sm-size1of3,
  .u-sm-size2of6,
  .u-sm-size4of12 {
    width: 33.33333% !important;
  }

  .u-sm-size3of8 {
    width: 37.5% !important;
  }

  .u-sm-size2of5,
  .u-sm-size4of10 {
    width: 40% !important;
  }

  .u-sm-size5of12 {
    width: 41.66667% !important;
  }

  .u-sm-size1of2,
  .u-sm-size2of4,
  .u-sm-size3of6,
  .u-sm-size4of8,
  .u-sm-size5of10,
  .u-sm-size6of12 {
    width: 50% !important;
  }

  .u-sm-size7of12 {
    width: 58.33333% !important;
  }

  .u-sm-size3of5,
  .u-sm-size6of10 {
    width: 60% !important;
  }

  .u-sm-size5of8 {
    width: 62.5% !important;
  }

  .u-sm-size2of3,
  .u-sm-size4of6,
  .u-sm-size8of12 {
    width: 66.66667% !important;
  }

  .u-sm-size7of10 {
    width: 70% !important;
  }

  .u-sm-size3of4,
  .u-sm-size6of8,
  .u-sm-size9of12 {
    width: 75% !important;
  }

  .u-sm-size4of5,
  .u-sm-size8of10 {
    width: 80% !important;
  }

  .u-sm-size5of6,
  .u-sm-size10of12 {
    width: 83.33333% !important;
  }

  .u-sm-size7of8 {
    width: 87.5% !important;
  }

  .u-sm-size9of10 {
    width: 90% !important;
  }

  .u-sm-size11of12 {
    width: 91.66667% !important;
  }

  /* Intrinsic widths
     ======================================================================== */

  /**
   * Make an element fill the remaining space.
   *
   * 1. Be explicit to work around IE10 bug with shorthand flex
   *    http://git.io/vllC7
   * 2. IE10 ignores previous `flex-basis` value. Setting again here fixes
   *    http://git.io/vllMt
   */

  .u-sm-sizeFill {
    -webkit-box-flex: 1 !important;
    -webkit-flex: 1 1 0% !important;
        -ms-flex: 1 1 0% !important;
            flex: 1 1 0% !important; /* 1 */
    -webkit-flex-basis: 0% !important;
        -ms-flex-preferred-size: 0% !important;
            flex-basis: 0% !important; /* 2 */
  }

  /**
   * An alternative method to make an element fill the remaining space.
   * Distributes space based on the initial width and height of the element
   *
   * http://www.w3.org/TR/css-flexbox/images/rel-vs-abs-flex.svg
   */

  .u-sm-sizeFillAlt {
    -webkit-box-flex: 1 !important;
    -webkit-flex: 1 1 auto !important;
        -ms-flex: 1 1 auto !important;
            flex: 1 1 auto !important;
    -webkit-flex-basis: auto !important;
        -ms-flex-preferred-size: auto !important;
            flex-basis: auto !important;
  }

  /**
   * Make an element the width of its parent.
   */

  .u-sm-sizeFull {
    box-sizing: border-box !important;
    display: block !important;
    width: 100% !important;
  }

}

/**
 * @define utilities
 * Size: breakpoint 2 (medium)
 */

@media (min-width:640px) and (max-width:960px) {

  /* Proportional widths: breakpoint 2 (medium)
     ======================================================================== */

  /**
   * Specify the proportional width of an object.
   * Intentional redundancy build into each set of unit classes.
   * Supports: 2, 3, 4, 5, 6, 8, 10, 12 part
   *
   * 1. Use `flex-basis: auto` with a width to avoid box-sizing bug in IE10/11
   *    http://git.io/vllMD
   */

  /* postcss-bem-linter: ignore */

  [class*="u-md-size"] {
    -webkit-flex-basis: auto !important;
        -ms-flex-preferred-size: auto !important;
            flex-basis: auto !important; /* 1 */
  }

  .u-md-size1of12 {
    width: 8.33333% !important;
  }

  .u-md-size1of10 {
    width: 10% !important;
  }

  .u-md-size1of8 {
    width: 12.5% !important;
  }

  .u-md-size1of6,
  .u-md-size2of12 {
    width: 16.66667% !important;
  }

  .u-md-size1of5,
  .u-md-size2of10 {
    width: 20% !important;
  }

  .u-md-size1of4,
  .u-md-size2of8,
  .u-md-size3of12 {
    width: 25% !important;
  }

  .u-md-size3of10 {
    width: 30% !important;
  }

  .u-md-size1of3,
  .u-md-size2of6,
  .u-md-size4of12 {
    width: 33.33333% !important;
  }

  .u-md-size3of8 {
    width: 37.5% !important;
  }

  .u-md-size2of5,
  .u-md-size4of10 {
    width: 40% !important;
  }

  .u-md-size5of12 {
    width: 41.66667% !important;
  }

  .u-md-size1of2,
  .u-md-size2of4,
  .u-md-size3of6,
  .u-md-size4of8,
  .u-md-size5of10,
  .u-md-size6of12 {
    width: 50% !important;
  }

  .u-md-size7of12 {
    width: 58.33333% !important;
  }

  .u-md-size3of5,
  .u-md-size6of10 {
    width: 60% !important;
  }

  .u-md-size5of8 {
    width: 62.5% !important;
  }

  .u-md-size2of3,
  .u-md-size4of6,
  .u-md-size8of12 {
    width: 66.66667% !important;
  }

  .u-md-size7of10 {
    width: 70% !important;
  }

  .u-md-size3of4,
  .u-md-size6of8,
  .u-md-size9of12 {
    width: 75% !important;
  }

  .u-md-size4of5,
  .u-md-size8of10 {
    width: 80% !important;
  }

  .u-md-size5of6,
  .u-md-size10of12 {
    width: 83.33333% !important;
  }

  .u-md-size7of8 {
    width: 87.5% !important;
  }

  .u-md-size9of10 {
    width: 90% !important;
  }

  .u-md-size11of12 {
    width: 91.66667% !important;
  }

  /* Intrinsic widths
     ======================================================================== */

  /**
   * Make an element fill the remaining space.
   *
   * 1. Be explicit to work around IE10 bug with shorthand flex
   *    http://git.io/vllC7
   * 2. IE10 ignores previous `flex-basis` value. Setting again here fixes
   *    http://git.io/vllMt
   */

  .u-md-sizeFill {
    -webkit-box-flex: 1 !important;
    -webkit-flex: 1 1 0% !important;
        -ms-flex: 1 1 0% !important;
            flex: 1 1 0% !important; /* 1 */
    -webkit-flex-basis: 0% !important;
        -ms-flex-preferred-size: 0% !important;
            flex-basis: 0% !important; /* 2 */
  }

  /**
   * An alternative method to make an element fill the remaining space.
   * Distributes space based on the initial width and height of the element
   *
   * http://www.w3.org/TR/css-flexbox/images/rel-vs-abs-flex.svg
   */

  .u-md-sizeFillAlt {
    -webkit-box-flex: 1 !important;
    -webkit-flex: 1 1 auto !important;
        -ms-flex: 1 1 auto !important;
            flex: 1 1 auto !important;
    -webkit-flex-basis: auto !important;
        -ms-flex-preferred-size: auto !important;
            flex-basis: auto !important;
  }

  /**
   * Make an element the width of its parent.
   */

  .u-md-sizeFull {
    box-sizing: border-box !important;
    display: block !important;
    width: 100% !important;
  }

}

/**
 * @define utilities
 * Size: breakpoint 3 (large)
 */

@media (min-width:960px) {

  /* Proportional widths: breakpoint 3 (large)
     ======================================================================== */

  /**
   * Specify the proportional width of an object.
   * Intentional redundancy build into each set of unit classes.
   * Supports: 2, 3, 4, 5, 6, 8, 10, 12 part
   *
   * 1. Use `flex-basis: auto` with a width to avoid box-sizing bug in IE10/11
   *    http://git.io/vllMD
   */

  /* postcss-bem-linter: ignore */

  [class*="u-lg-size"] {
    -webkit-flex-basis: auto !important;
        -ms-flex-preferred-size: auto !important;
            flex-basis: auto !important; /* 1 */
  }

  .u-lg-size1of12 {
    width: 8.33333% !important;
  }

  .u-lg-size1of10 {
    width: 10% !important;
  }

  .u-lg-size1of8 {
    width: 12.5% !important;
  }

  .u-lg-size1of6,
  .u-lg-size2of12 {
    width: 16.66667% !important;
  }

  .u-lg-size1of5,
  .u-lg-size2of10 {
    width: 20% !important;
  }

  .u-lg-size1of4,
  .u-lg-size2of8,
  .u-lg-size3of12 {
    width: 25% !important;
  }

  .u-lg-size3of10 {
    width: 30% !important;
  }

  .u-lg-size1of3,
  .u-lg-size2of6,
  .u-lg-size4of12 {
    width: 33.33333% !important;
  }

  .u-lg-size3of8 {
    width: 37.5% !important;
  }

  .u-lg-size2of5,
  .u-lg-size4of10 {
    width: 40% !important;
  }

  .u-lg-size5of12 {
    width: 41.66667% !important;
  }

  .u-lg-size1of2,
  .u-lg-size2of4,
  .u-lg-size3of6,
  .u-lg-size4of8,
  .u-lg-size5of10,
  .u-lg-size6of12 {
    width: 50% !important;
  }

  .u-lg-size7of12 {
    width: 58.33333% !important;
  }

  .u-lg-size3of5,
  .u-lg-size6of10 {
    width: 60% !important;
  }

  .u-lg-size5of8 {
    width: 62.5% !important;
  }

  .u-lg-size2of3,
  .u-lg-size4of6,
  .u-lg-size8of12 {
    width: 66.66667% !important;
  }

  .u-lg-size7of10 {
    width: 70% !important;
  }

  .u-lg-size3of4,
  .u-lg-size6of8,
  .u-lg-size9of12 {
    width: 75% !important;
  }

  .u-lg-size4of5,
  .u-lg-size8of10 {
    width: 80% !important;
  }

  .u-lg-size5of6,
  .u-lg-size10of12 {
    width: 83.33333% !important;
  }

  .u-lg-size7of8 {
    width: 87.5% !important;
  }

  .u-lg-size9of10 {
    width: 90% !important;
  }

  .u-lg-size11of12 {
    width: 91.66667% !important;
  }

  /* Intrinsic widths
     ======================================================================== */

  /**
   * Make an element fill the remaining space.
   *
   * 1. Be explicit to work around IE10 bug with shorthand flex
   *    http://git.io/vllC7
   * 2. IE10 ignores previous `flex-basis` value. Setting again here fixes
   *    http://git.io/vllMt
   */

  .u-lg-sizeFill {
    -webkit-box-flex: 1 !important;
    -webkit-flex: 1 1 0% !important;
        -ms-flex: 1 1 0% !important;
            flex: 1 1 0% !important; /* 1 */
    -webkit-flex-basis: 0% !important;
        -ms-flex-preferred-size: 0% !important;
            flex-basis: 0% !important; /* 2 */
  }

  /**
   * An alternative method to make an element fill the remaining space.
   * Distributes space based on the initial width and height of the element
   *
   * http://www.w3.org/TR/css-flexbox/images/rel-vs-abs-flex.svg
   */

  .u-lg-sizeFillAlt {
    -webkit-box-flex: 1 !important;
    -webkit-flex: 1 1 auto !important;
        -ms-flex: 1 1 auto !important;
            flex: 1 1 auto !important;
    -webkit-flex-basis: auto !important;
        -ms-flex-preferred-size: auto !important;
            flex-basis: auto !important;
  }

  /**
   * Make an element the width of its parent.
   */

  .u-lg-sizeFull {
    box-sizing: border-box !important;
    display: block !important;
    width: 100% !important;
  }

}

/**
 * Specify the proportional offset after an element.
 * Intentional redundancy build into each set of unit classes.
 * Supports: 2, 4, 5, 6, 8, 10, 12 section
 */

.u-after1of12 {
  margin-right: 8.33333% !important;
}

.u-after1of10 {
  margin-right: 10% !important;
}

.u-after1of8 {
  margin-right: 12.5% !important;
}

.u-after1of6,
.u-after2of12 {
  margin-right: 16.66667% !important;
}

.u-after1of5,
.u-after2of10 {
  margin-right: 20% !important;
}

.u-after1of4,
.u-after2of8,
.u-after3of12 {
  margin-right: 25% !important;
}

.u-after3of10 {
  margin-right: 30% !important;
}

.u-after1of3,
.u-after2of6,
.u-after4of12 {
  margin-right: 33.33333% !important;
}

.u-after3of8 {
  margin-right: 37.5% !important;
}

.u-after2of5,
.u-after4of10 {
  margin-right: 40% !important;
}

.u-after5of12 {
  margin-right: 41.66667% !important;
}

.u-after1of2,
.u-after2of4,
.u-after3of6,
.u-after4of8,
.u-after5of10,
.u-after6of12 {
  margin-right: 50% !important;
}

.u-after7of12 {
  margin-right: 58.33333% !important;
}

.u-after3of5,
.u-after6of10 {
  margin-right: 60% !important;
}

.u-after5of8 {
  margin-right: 62.5% !important;
}

.u-after2of3,
.u-after4of6,
.u-after8of12 {
  margin-right: 66.66667% !important;
}

.u-after7of10 {
  margin-right: 70% !important;
}

.u-after3of4,
.u-after6of8,
.u-after9of12 {
  margin-right: 75% !important;
}

.u-after4of5,
.u-after8of10 {
  margin-right: 80% !important;
}

.u-after5of6,
.u-after10of12 {
  margin-right: 83.33333% !important;
}

.u-after7of8 {
  margin-right: 87.5% !important;
}

.u-after9of10 {
  margin-right: 90% !important;
}

.u-after11of12 {
  margin-right: 91.66667% !important;
}

/**
 * Offset: breakpoint 1 (small)
 *
 * Specify the proportional offset after an element.
 * Intentional redundancy build into each set of unit classes.
 * Supports: 2, 4, 5, 6, 8, 10, 12 section
 */

@media (min-width:320px) and (max-width:640px) {

  .u-sm-afterNone {
    margin-left: 0 !important;
  }

  .u-sm-after1of12 {
    margin-right: 8.33333% !important;
  }

  .u-sm-after1of10 {
    margin-right: 10% !important;
  }

  .u-sm-after1of8 {
    margin-right: 12.5% !important;
  }

  .u-sm-after1of6,
  .u-sm-after2of12 {
    margin-right: 16.66667% !important;
  }

  .u-sm-after1of5,
  .u-sm-after2of10 {
    margin-right: 20% !important;
  }

  .u-sm-after1of4,
  .u-sm-after2of8,
  .u-sm-after3of12 {
    margin-right: 25% !important;
  }

  .u-sm-after3of10 {
    margin-right: 30% !important;
  }

  .u-sm-after1of3,
  .u-sm-after2of6,
  .u-sm-after4of12 {
    margin-right: 33.33333% !important;
  }

  .u-sm-after3of8 {
    margin-right: 37.5% !important;
  }

  .u-sm-after2of5,
  .u-sm-after4of10 {
    margin-right: 40% !important;
  }

  .u-sm-after5of12 {
    margin-right: 41.66667% !important;
  }

  .u-sm-after1of2,
  .u-sm-after2of4,
  .u-sm-after3of6,
  .u-sm-after4of8,
  .u-sm-after5of10,
  .u-sm-after6of12 {
    margin-right: 50% !important;
  }

  .u-sm-after7of12 {
    margin-right: 58.33333% !important;
  }

  .u-sm-after3of5,
  .u-sm-after6of10 {
    margin-right: 60% !important;
  }

  .u-sm-after5of8 {
    margin-right: 62.5% !important;
  }

  .u-sm-after2of3,
  .u-sm-after4of6,
  .u-sm-after8of12 {
    margin-right: 66.66667% !important;
  }

  .u-sm-after7of10 {
    margin-right: 70% !important;
  }

  .u-sm-after3of4,
  .u-sm-after6of8,
  .u-sm-after9of12 {
    margin-right: 75% !important;
  }

  .u-sm-after4of5,
  .u-sm-after8of10 {
    margin-right: 80% !important;
  }

  .u-sm-after5of6,
  .u-sm-after10of12 {
    margin-right: 83.33333% !important;
  }

  .u-sm-after7of8 {
    margin-right: 87.5% !important;
  }

  .u-sm-after9of10 {
    margin-right: 90% !important;
  }

  .u-sm-after11of12 {
    margin-right: 91.66667% !important;
  }

}

/**
 * Offset: breakpoint 2 (medium)
 *
 * Specify the proportional offset after an element.
 * Intentional redundancy build into each set of unit classes.
 * Supports: 2, 4, 5, 6, 8, 10, 12 section
 */

@media (min-width:640px) and (max-width:960px) {

  .u-md-afterNone {
    margin-left: 0 !important;
  }

  .u-md-after1of12 {
    margin-right: 8.33333% !important;
  }

  .u-md-after1of10 {
    margin-right: 10% !important;
  }

  .u-md-after1of8 {
    margin-right: 12.5% !important;
  }

  .u-md-after1of6,
  .u-md-after2of12 {
    margin-right: 16.66667% !important;
  }

  .u-md-after1of5,
  .u-md-after2of10 {
    margin-right: 20% !important;
  }

  .u-md-after1of4,
  .u-md-after2of8,
  .u-md-after3of12 {
    margin-right: 25% !important;
  }

  .u-md-after3of10 {
    margin-right: 30% !important;
  }

  .u-md-after1of3,
  .u-md-after2of6,
  .u-md-after4of12 {
    margin-right: 33.33333% !important;
  }

  .u-md-after3of8 {
    margin-right: 37.5% !important;
  }

  .u-md-after2of5,
  .u-md-after4of10 {
    margin-right: 40% !important;
  }

  .u-md-after5of12 {
    margin-right: 41.66667% !important;
  }

  .u-md-after1of2,
  .u-md-after2of4,
  .u-md-after3of6,
  .u-md-after4of8,
  .u-md-after5of10,
  .u-md-after6of12 {
    margin-right: 50% !important;
  }

  .u-md-after7of12 {
    margin-right: 58.33333% !important;
  }

  .u-md-after3of5,
  .u-md-after6of10 {
    margin-right: 60% !important;
  }

  .u-md-after5of8 {
    margin-right: 62.5% !important;
  }

  .u-md-after2of3,
  .u-md-after4of6,
  .u-md-after8of12 {
    margin-right: 66.66667% !important;
  }

  .u-md-after7of10 {
    margin-right: 70% !important;
  }

  .u-md-after3of4,
  .u-md-after6of8,
  .u-md-after9of12 {
    margin-right: 75% !important;
  }

  .u-md-after4of5,
  .u-md-after8of10 {
    margin-right: 80% !important;
  }

  .u-md-after5of6,
  .u-md-after10of12 {
    margin-right: 83.33333% !important;
  }

  .u-md-after7of8 {
    margin-right: 87.5% !important;
  }

  .u-md-after9of10 {
    margin-right: 90% !important;
  }

  .u-md-after11of12 {
    margin-right: 91.66667% !important;
  }

}

/**
 * Offset: breakpoint 3 (large)
 *
 * Specify the proportional offset after an element.
 * Intentional redundancy build into each set of unit classes.
 * Supports: 2, 4, 5, 6, 8, 10, 12 section
 */

@media (min-width:960px) {

  .u-lg-afterNone {
    margin-left: 0 !important;
  }

  .u-lg-after1of12 {
    margin-right: 8.33333% !important;
  }

  .u-lg-after1of10 {
    margin-right: 10% !important;
  }

  .u-lg-after1of8 {
    margin-right: 12.5% !important;
  }

  .u-lg-after1of6,
  .u-lg-after2of12 {
    margin-right: 16.66667% !important;
  }

  .u-lg-after1of5,
  .u-lg-after2of10 {
    margin-right: 20% !important;
  }

  .u-lg-after1of4,
  .u-lg-after2of8,
  .u-lg-after3of12 {
    margin-right: 25% !important;
  }

  .u-lg-after3of10 {
    margin-right: 30% !important;
  }

  .u-lg-after1of3,
  .u-lg-after2of6,
  .u-lg-after4of12 {
    margin-right: 33.33333% !important;
  }

  .u-lg-after3of8 {
    margin-right: 37.5% !important;
  }

  .u-lg-after2of5,
  .u-lg-after4of10 {
    margin-right: 40% !important;
  }

  .u-lg-after5of12 {
    margin-right: 41.66667% !important;
  }

  .u-lg-after1of2,
  .u-lg-after2of4,
  .u-lg-after3of6,
  .u-lg-after4of8,
  .u-lg-after5of10,
  .u-lg-after6of12 {
    margin-right: 50% !important;
  }

  .u-lg-after7of12 {
    margin-right: 58.33333% !important;
  }

  .u-lg-after3of5,
  .u-lg-after6of10 {
    margin-right: 60% !important;
  }

  .u-lg-after5of8 {
    margin-right: 62.5% !important;
  }

  .u-lg-after2of3,
  .u-lg-after4of6,
  .u-lg-after8of12 {
    margin-right: 66.66667% !important;
  }

  .u-lg-after7of10 {
    margin-right: 70% !important;
  }

  .u-lg-after3of4,
  .u-lg-after6of8,
  .u-lg-after9of12 {
    margin-right: 75% !important;
  }

  .u-lg-after4of5,
  .u-lg-after8of10 {
    margin-right: 80% !important;
  }

  .u-lg-after5of6,
  .u-lg-after10of12 {
    margin-right: 83.33333% !important;
  }

  .u-lg-after7of8 {
    margin-right: 87.5% !important;
  }

  .u-lg-after9of10 {
    margin-right: 90% !important;
  }

  .u-lg-after11of12 {
    margin-right: 91.66667% !important;
  }

}

/**
 * Specify the proportional offset before an object.
 * Intentional redundancy build into each set of unit classes.
 * Supports: 2, 3, 4, 5, 6, 8, 10, 12 section
 */

.u-before1of12 {
  margin-left: 8.33333% !important;
}

.u-before1of10 {
  margin-left: 10% !important;
}

.u-before1of8 {
  margin-left: 12.5% !important;
}

.u-before1of6,
.u-before2of12 {
  margin-left: 16.66667% !important;
}

.u-before1of5,
.u-before2of10 {
  margin-left: 20% !important;
}

.u-before1of4,
.u-before2of8,
.u-before3of12 {
  margin-left: 25% !important;
}

.u-before3of10 {
  margin-left: 30% !important;
}

.u-before1of3,
.u-before2of6,
.u-before4of12 {
  margin-left: 33.33333% !important;
}

.u-before3of8 {
  margin-left: 37.5% !important;
}

.u-before2of5,
.u-before4of10 {
  margin-left: 40% !important;
}

.u-before5of12 {
  margin-left: 41.66667% !important;
}

.u-before1of2,
.u-before2of4,
.u-before3of6,
.u-before4of8,
.u-before5of10,
.u-before6of12 {
  margin-left: 50% !important;
}

.u-before7of12 {
  margin-left: 58.33333% !important;
}

.u-before3of5,
.u-before6of10 {
  margin-left: 60% !important;
}

.u-before5of8 {
  margin-left: 62.5% !important;
}

.u-before2of3,
.u-before4of6,
.u-before8of12 {
  margin-left: 66.66667% !important;
}

.u-before7of10 {
  margin-left: 70% !important;
}

.u-before3of4,
.u-before6of8,
.u-before9of12 {
  margin-left: 75% !important;
}

.u-before4of5,
.u-before8of10 {
  margin-left: 80% !important;
}

.u-before5of6,
.u-before10of12 {
  margin-left: 83.33333% !important;
}

.u-before7of8 {
  margin-left: 87.5% !important;
}

.u-before9of10 {
  margin-left: 90% !important;
}

.u-before11of12 {
  margin-left: 91.66667% !important;
}

/**
 * Offset: breakpoint 1 (small)
 *
 * Specify the proportional offset before an element.
 * Intentional redundancy build into each set of unit classes.
 * Supports: 2, 3, 4, 5, 6, 8, 10, 12 section
 */

@media (min-width:320px) and (max-width:640px) {

  .u-sm-beforeNone {
    margin-left: 0 !important;
  }

  .u-sm-before1of12 {
    margin-left: 8.33333% !important;
  }

  .u-sm-before1of10 {
    margin-left: 10% !important;
  }

  .u-sm-before1of8 {
    margin-left: 12.5% !important;
  }

  .u-sm-before1of6,
  .u-sm-before2of12 {
    margin-left: 16.66667% !important;
  }

  .u-sm-before1of5,
  .u-sm-before2of10 {
    margin-left: 20% !important;
  }

  .u-sm-before1of4,
  .u-sm-before2of8,
  .u-sm-before3of12 {
    margin-left: 25% !important;
  }

  .u-sm-before3of10 {
    margin-left: 30% !important;
  }

  .u-sm-before1of3,
  .u-sm-before2of6,
  .u-sm-before4of12 {
    margin-left: 33.33333% !important;
  }

  .u-sm-before3of8 {
    margin-left: 37.5% !important;
  }

  .u-sm-before2of5,
  .u-sm-before4of10 {
    margin-left: 40% !important;
  }

  .u-sm-before5of12 {
    margin-left: 41.66667% !important;
  }

  .u-sm-before1of2,
  .u-sm-before2of4,
  .u-sm-before3of6,
  .u-sm-before4of8,
  .u-sm-before5of10,
  .u-sm-before6of12 {
    margin-left: 50% !important;
  }

  .u-sm-before7of12 {
    margin-left: 58.33333% !important;
  }

  .u-sm-before3of5,
  .u-sm-before6of10 {
    margin-left: 60% !important;
  }

  .u-sm-before5of8 {
    margin-left: 62.5% !important;
  }

  .u-sm-before2of3,
  .u-sm-before4of6,
  .u-sm-before8of12 {
    margin-left: 66.66667% !important;
  }

  .u-sm-before7of10 {
    margin-left: 70% !important;
  }

  .u-sm-before3of4,
  .u-sm-before6of8,
  .u-sm-before9of12 {
    margin-left: 75% !important;
  }

  .u-sm-before4of5,
  .u-sm-before8of10 {
    margin-left: 80% !important;
  }

  .u-sm-before5of6,
  .u-sm-before10of12 {
    margin-left: 83.33333% !important;
  }

  .u-sm-before7of8 {
    margin-left: 87.5% !important;
  }

  .u-sm-before9of10 {
    margin-left: 90% !important;
  }

  .u-sm-before11of12 {
    margin-left: 91.66667% !important;
  }

}

/**
 * Offset: breakpoint 2 (medium)
 *
 * Specify the proportional offset before an element.
 * Intentional redundancy build into each set of unit classes.
 * Supports: 2, 3, 4, 5, 6, 8, 10, 12 section
 */

@media (min-width:640px) and (max-width:960px) {

  .u-md-beforeNone {
    margin-left: 0 !important;
  }

  .u-md-before1of12 {
    margin-left: 8.33333% !important;
  }

  .u-md-before1of10 {
    margin-left: 10% !important;
  }

  .u-md-before1of8 {
    margin-left: 12.5% !important;
  }

  .u-md-before1of6,
  .u-md-before2of12 {
    margin-left: 16.66667% !important;
  }

  .u-md-before1of5,
  .u-md-before2of10 {
    margin-left: 20% !important;
  }

  .u-md-before1of4,
  .u-md-before2of8,
  .u-md-before3of12 {
    margin-left: 25% !important;
  }

  .u-md-before3of10 {
    margin-left: 30% !important;
  }

  .u-md-before1of3,
  .u-md-before2of6,
  .u-md-before4of12 {
    margin-left: 33.33333% !important;
  }

  .u-md-before3of8 {
    margin-left: 37.5% !important;
  }

  .u-md-before2of5,
  .u-md-before4of10 {
    margin-left: 40% !important;
  }

  .u-md-before5of12 {
    margin-left: 41.66667% !important;
  }

  .u-md-before1of2,
  .u-md-before2of4,
  .u-md-before3of6,
  .u-md-before4of8,
  .u-md-before5of10,
  .u-md-before6of12 {
    margin-left: 50% !important;
  }

  .u-md-before7of12 {
    margin-left: 58.33333% !important;
  }

  .u-md-before3of5,
  .u-md-before6of10 {
    margin-left: 60% !important;
  }

  .u-md-before5of8 {
    margin-left: 62.5% !important;
  }

  .u-md-before2of3,
  .u-md-before4of6,
  .u-md-before8of12 {
    margin-left: 66.66667% !important;
  }

  .u-md-before7of10 {
    margin-left: 70% !important;
  }

  .u-md-before3of4,
  .u-md-before6of8,
  .u-md-before9of12 {
    margin-left: 75% !important;
  }

  .u-md-before4of5,
  .u-md-before8of10 {
    margin-left: 80% !important;
  }

  .u-md-before5of6,
  .u-md-before10of12 {
    margin-left: 83.33333% !important;
  }

  .u-md-before7of8 {
    margin-left: 87.5% !important;
  }

  .u-md-before9of10 {
    margin-left: 90% !important;
  }

  .u-md-before11of12 {
    margin-left: 91.66667% !important;
  }

}

/**
 * Offset: breakpoint 3 (large)
 *
 * Specify the proportional offset before an element.
 * Intentional redundancy build into each set of unit classes.
 * Supports: 2, 3, 4, 5, 6, 8, 10, 12 section
 */

@media (min-width:960px) {

  .u-lg-beforeNone {
    margin-left: 0 !important;
  }

  .u-lg-before1of12 {
    margin-left: 8.33333% !important;
  }

  .u-lg-before1of10 {
    margin-left: 10% !important;
  }

  .u-lg-before1of8 {
    margin-left: 12.5% !important;
  }

  .u-lg-before1of6,
  .u-lg-before2of12 {
    margin-left: 16.66667% !important;
  }

  .u-lg-before1of5,
  .u-lg-before2of10 {
    margin-left: 20% !important;
  }

  .u-lg-before1of4,
  .u-lg-before2of8,
  .u-lg-before3of12 {
    margin-left: 25% !important;
  }

  .u-lg-before3of10 {
    margin-left: 30% !important;
  }

  .u-lg-before1of3,
  .u-lg-before2of6,
  .u-lg-before4of12 {
    margin-left: 33.33333% !important;
  }

  .u-lg-before3of8 {
    margin-left: 37.5% !important;
  }

  .u-lg-before2of5,
  .u-lg-before4of10 {
    margin-left: 40% !important;
  }

  .u-lg-before5of12 {
    margin-left: 41.66667% !important;
  }

  .u-lg-before1of2,
  .u-lg-before2of4,
  .u-lg-before3of6,
  .u-lg-before4of8,
  .u-lg-before5of10,
  .u-lg-before6of12 {
    margin-left: 50% !important;
  }

  .u-lg-before7of12 {
    margin-left: 58.33333% !important;
  }

  .u-lg-before3of5,
  .u-lg-before6of10 {
    margin-left: 60% !important;
  }

  .u-lg-before5of8 {
    margin-left: 62.5% !important;
  }

  .u-lg-before2of3,
  .u-lg-before4of6,
  .u-lg-before8of12 {
    margin-left: 66.66667% !important;
  }

  .u-lg-before7of10 {
    margin-left: 70% !important;
  }

  .u-lg-before3of4,
  .u-lg-before6of8,
  .u-lg-before9of12 {
    margin-left: 75% !important;
  }

  .u-lg-before4of5,
  .u-lg-before8of10 {
    margin-left: 80% !important;
  }

  .u-lg-before5of6,
  .u-lg-before10of12 {
    margin-left: 83.33333% !important;
  }

  .u-lg-before7of8 {
    margin-left: 87.5% !important;
  }

  .u-lg-before9of10 {
    margin-left: 90% !important;
  }

  .u-lg-before11of12 {
    margin-left: 91.66667% !important;
  }

}

/** @define Grid */

/**
 * Core grid component
 *
 * DO NOT apply dimension or offset utilities to the `Grid` element. All cell
 * widths and offsets should be applied to child grid cells.
 */

/* Grid container
   ========================================================================== */

/**
 * All content must be contained within child `Grid-cell` elements.
 *
 * 1. Account for browser defaults of elements that might be the root node of
 *    the component.
 */

.Grid {
  box-sizing: border-box;
  display: -webkit-box;
  display: -webkit-flex;
  display: -ms-flexbox;
  display: flex; /* 1 */
  -webkit-flex-flow: row wrap;
      -ms-flex-flow: row wrap;
          flex-flow: row wrap;
  margin: 0; /* 1 */
  padding: 0; /* 1 */
}

/**
 * Modifier: center align all grid cells
 */

.Grid--alignCenter {
  -webkit-box-pack: center;
  -webkit-justify-content: center;
      -ms-flex-pack: center;
          justify-content: center;
}

/**
 * Modifier: right align all grid cells
 */

.Grid--alignRight {
  -webkit-box-pack: end;
  -webkit-justify-content: flex-end;
      -ms-flex-pack: end;
          justify-content: flex-end;
}

/**
 * Modifier: middle-align grid cells
 */

.Grid--alignMiddle {
  -webkit-box-align: center;
  -webkit-align-items: center;
      -ms-flex-align: center;
              -ms-grid-row-align: center;
          align-items: center;
}

/**
 * Modifier: bottom-align grid cells
 */

.Grid--alignBottom {
  -webkit-box-align: end;
  -webkit-align-items: flex-end;
      -ms-flex-align: end;
              -ms-grid-row-align: flex-end;
          align-items: flex-end;
}

/**
 * Modifier: allow cells to equal distribute width
 *
 * 1. Provide all values to avoid IE10 bug with shorthand flex
 *    http://git.io/vllC7
 *
 *    Use `0%` to avoid bug in IE10/11 with unitless flex basis
 *    http://git.io/vllWx
 */

.Grid--fit > .Grid-cell {
  -webkit-box-flex: 1;
  -webkit-flex: 1 1 0%;
      -ms-flex: 1 1 0%;
          flex: 1 1 0%; /* 1 */
}

/**
 * Modifier: all cells match height of tallest cell in a row
 */

.Grid--equalHeight > .Grid-cell {
  display: -webkit-box;
  display: -webkit-flex;
  display: -ms-flexbox;
  display: flex;
}

/**
 * Modifier: gutters
 */

.Grid--withGutter {
  margin: 0 -10px;
}

.Grid--withGutter > .Grid-cell {
  padding: 0 10px;
}

/* Grid cell
   ========================================================================== */

/**
 * No explicit width by default. Rely on combining `Grid-cell` with a dimension
 * utility or a component class that extends 'Grid'.
 *
 * 1. Set flex items to full width by default
 * 2. Fix issue where elements with overflow extend past the
 *    `Grid-cell` container - https://git.io/vw5oF
 */

.Grid-cell {
  box-sizing: inherit;
  -webkit-flex-basis: 100%;
      -ms-flex-preferred-size: 100%;
          flex-basis: 100%; /* 1 */
  min-width: 0; /* 2 */
}

/**
 * Modifier: horizontally center one unit
 * Set a specific unit to be horizontally centered. Doesn't affect
 * any other units. Can still contain a child `Grid` object.
 */

.Grid-cell--center {
  margin: 0 auto;
}