* {
  box-sizing: border-box;
  margin: 0
}

@font-face {
  font-family: 'Bauhaus Std';
  src: url('../fonts/BauhausStd-Light.woff2') format('woff2'),
    url('../fonts/BauhausStd-Light.woff') format('woff');
  font-weight: 300;
  font-style: normal;
  font-display: swap;
}

@font-face {
  font-family: 'Bauhaus Std';
  src: url('../fonts/BauhausStd-Medium.woff2') format('woff2'),
    url('../fonts/BauhausStd-Medium.woff') format('woff');
  font-weight: 500;
  font-style: normal;
  font-display: swap;
}

body {
  background-color: #F6F3F0;
  margin: 0;
  font-family: "Montserrat", sans-serif;
  font-optical-sizing: auto;
  font-weight: 400;
  font-style: normal;
  overflow-x: hidden;
}

a {
  color: #5f8a6e;
  text-decoration: none;
}

a:hover {
  color: #0A3F39;
  text-decoration: none;
}


img {
  max-width: 100%;
}

.hex-image {
  width: 150px;
  height: 127px;
  object-fit: cover;
  -webkit-clip-path: polygon(0% 50%, 25% 0%, 75% 0%, 100% 50%, 75% 100%, 25% 100%);
  -moz-clip-path: polygon(0% 50%, 25% 0%, 75% 0%, 100% 50%, 75% 100%, 25% 100%);
}

.container-fluid {
  padding-right: 0.9375rem;
  padding-left: 0.9375rem;
  margin-right: auto;
  margin-left: auto;
}

.hex-grid {

  /* margin: 0; */
}

.hex-grid .hex-row {
  display: table;
  margin-top: -6.8571428571px;
}

.hex-grid .hex-col {
  float: left;
  position: relative;
  margin-top: -2px;
}

.hex-grid .hex-wrapper {
  position: absolute;
  top: 0;
  /* Offset position within the col-container */
  left: 16.6666666667%;
  right: 16.6666666667%;
  height: 0;
  padding: 0;
  padding-bottom: 59.0476190476%;
}

.hex-grid .hex-svg {
  padding: 38.857143px 10px;
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 0) {
  .hex-grid .hex-row {
    width: 150%;
    margin-left: -25%;
  }

  .hex-grid .hex-col {
    width: 100%;
    padding-bottom: 59.0476190476%;
  }
}

/*== Grid CSS 3: More than one colum case */
/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 0) {
  .hex-grid-xxs-1 .hex-row {
    width: 150%;
    margin-left: -25%;
  }

  .hex-grid-xxs-1 .hex-col {
    width: 100%;
    padding-bottom: 59.0476190476%;
  }
}

/*== Grid CSS 3: More than one colum case */
/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 0) {
  .hex-grid-xxs-2 .hex-row {
    width: 128.5714285714%;
    margin-left: -14.2857142857%;
  }

  .hex-grid-xxs-2 .hex-col {
    width: 66.6666666667%;
    padding-bottom: 39.3650793651%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 0) {
  .hex-grid-xxs-2 .hex-row {
    padding-bottom: 25.306122449%;
  }

  .hex-grid-xxs-2 .hex-col {
    padding-bottom: 19.6825396825%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xxs-2 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xxs-2 .hex-col:nth-child(2n+2) {
    margin-left: 33.3333333333%;
  }

  .hex-grid-xxs-2 .hex-col:nth-child(2n+1) {
    margin-right: 33.3333333333%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 0) {
  .hex-grid-xxs-3 .hex-row {
    width: 120%;
    margin-left: -10%;
  }

  .hex-grid-xxs-3 .hex-col {
    width: 50%;
    padding-bottom: 29.5238095238%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 0) {
  .hex-grid-xxs-3 .hex-row {
    padding-bottom: 17.7142857143%;
  }

  .hex-grid-xxs-3 .hex-col {
    padding-bottom: 14.7619047619%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xxs-3 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xxs-3 .hex-col:nth-child(3n+3) {
    margin-left: 25%;
  }

  .hex-grid-xxs-3 .hex-col:nth-child(3n+3) {
    margin-right: 25%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 0) {
  .hex-grid-xxs-4 .hex-row {
    width: 115.3846153846%;
    margin-left: -7.6923076923%;
  }

  .hex-grid-xxs-4 .hex-col {
    width: 40%;
    padding-bottom: 23.619047619%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 0) {
  .hex-grid-xxs-4 .hex-row {
    padding-bottom: 13.6263736264%;
  }

  .hex-grid-xxs-4 .hex-col {
    padding-bottom: 11.8095238095%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xxs-4 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xxs-4 .hex-col:nth-child(4n+3) {
    margin-left: 20%;
  }

  .hex-grid-xxs-4 .hex-col:nth-child(4n+2) {
    margin-right: 20%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 0) {
  .hex-grid-xxs-5 .hex-row {
    width: 112.5%;
    margin-left: -6.25%;
  }

  .hex-grid-xxs-5 .hex-col {
    width: 33.3333333333%;
    padding-bottom: 19.6825396825%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 0) {
  .hex-grid-xxs-5 .hex-row {
    padding-bottom: 11.0714285714%;
  }

  .hex-grid-xxs-5 .hex-col {
    padding-bottom: 9.8412698413%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xxs-5 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xxs-5 .hex-col:nth-child(5n+4) {
    margin-left: 16.6666666667%;
  }

  .hex-grid-xxs-5 .hex-col:nth-child(5n+5) {
    margin-right: 16.6666666667%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 0) {
  .hex-grid-xxs-6 .hex-row {
    width: 110.5263157895%;
    margin-left: -5.2631578947%;
  }

  .hex-grid-xxs-6 .hex-col {
    width: 28.5714285714%;
    padding-bottom: 16.8707482993%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 0) {
  .hex-grid-xxs-6 .hex-row {
    padding-bottom: 9.3233082707%;
  }

  .hex-grid-xxs-6 .hex-col {
    padding-bottom: 8.4353741497%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xxs-6 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xxs-6 .hex-col:nth-child(6n+4) {
    margin-left: 14.2857142857%;
  }

  .hex-grid-xxs-6 .hex-col:nth-child(6n+3) {
    margin-right: 14.2857142857%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 0) {
  .hex-grid-xxs-7 .hex-row {
    width: 109.0909090909%;
    margin-left: -4.5454545455%;
  }

  .hex-grid-xxs-7 .hex-col {
    width: 25%;
    padding-bottom: 14.7619047619%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 0) {
  .hex-grid-xxs-7 .hex-row {
    padding-bottom: 8.0519480519%;
  }

  .hex-grid-xxs-7 .hex-col {
    padding-bottom: 7.380952381%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xxs-7 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xxs-7 .hex-col:nth-child(7n+5) {
    margin-left: 12.5%;
  }

  .hex-grid-xxs-7 .hex-col:nth-child(7n+7) {
    margin-right: 12.5%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 0) {
  .hex-grid-xxs-8 .hex-row {
    width: 108%;
    margin-left: -4%;
  }

  .hex-grid-xxs-8 .hex-col {
    width: 22.2222222222%;
    padding-bottom: 13.1216931217%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 0) {
  .hex-grid-xxs-8 .hex-row {
    padding-bottom: 7.0857142857%;
  }

  .hex-grid-xxs-8 .hex-col {
    padding-bottom: 6.5608465608%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xxs-8 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xxs-8 .hex-col:nth-child(8n+5) {
    margin-left: 11.1111111111%;
  }

  .hex-grid-xxs-8 .hex-col:nth-child(8n+4) {
    margin-right: 11.1111111111%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 0) {
  .hex-grid-xxs-9 .hex-row {
    width: 107.1428571429%;
    margin-left: -3.5714285714%;
  }

  .hex-grid-xxs-9 .hex-col {
    width: 20%;
    padding-bottom: 11.8095238095%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 0) {
  .hex-grid-xxs-9 .hex-row {
    padding-bottom: 6.3265306122%;
  }

  .hex-grid-xxs-9 .hex-col {
    padding-bottom: 5.9047619048%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xxs-9 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xxs-9 .hex-col:nth-child(9n+6) {
    margin-left: 10%;
  }

  .hex-grid-xxs-9 .hex-col:nth-child(9n+9) {
    margin-right: 10%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 0) {
  .hex-grid-xxs-10 .hex-row {
    width: 106.4516129032%;
    margin-left: -3.2258064516%;
  }

  .hex-grid-xxs-10 .hex-col {
    width: 18.1818181818%;
    padding-bottom: 10.7359307359%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 0) {
  .hex-grid-xxs-10 .hex-row {
    padding-bottom: 5.7142857143%;
  }

  .hex-grid-xxs-10 .hex-col {
    padding-bottom: 5.367965368%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xxs-10 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xxs-10 .hex-col:nth-child(10n+6) {
    margin-left: 9.0909090909%;
  }

  .hex-grid-xxs-10 .hex-col:nth-child(10n+5) {
    margin-right: 9.0909090909%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 0) {
  .hex-grid-xxs-11 .hex-row {
    width: 105.8823529412%;
    margin-left: -2.9411764706%;
  }

  .hex-grid-xxs-11 .hex-col {
    width: 16.6666666667%;
    padding-bottom: 9.8412698413%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 0) {
  .hex-grid-xxs-11 .hex-row {
    padding-bottom: 5.2100840336%;
  }

  .hex-grid-xxs-11 .hex-col {
    padding-bottom: 4.9206349206%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xxs-11 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xxs-11 .hex-col:nth-child(11n+7) {
    margin-left: 8.3333333333%;
  }

  .hex-grid-xxs-11 .hex-col:nth-child(11n+11) {
    margin-right: 8.3333333333%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 0) {
  .hex-grid-xxs-12 .hex-row {
    width: 105.4054054054%;
    margin-left: -2.7027027027%;
  }

  .hex-grid-xxs-12 .hex-col {
    width: 15.3846153846%;
    padding-bottom: 9.0842490842%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 0) {
  .hex-grid-xxs-12 .hex-row {
    padding-bottom: 4.7876447876%;
  }

  .hex-grid-xxs-12 .hex-col {
    padding-bottom: 4.5421245421%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xxs-12 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xxs-12 .hex-col:nth-child(12n+7) {
    margin-left: 7.6923076923%;
  }

  .hex-grid-xxs-12 .hex-col:nth-child(12n+6) {
    margin-right: 7.6923076923%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 350px) {
  .hex-grid-xs-1 .hex-row {
    width: 150%;
    margin-left: -25%;
  }

  .hex-grid-xs-1 .hex-col {
    width: 100%;
    padding-bottom: 59.0476190476%;
  }
}

/*== Grid CSS 3: More than one colum case */
/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 350px) {
  .hex-grid-xs-2 .hex-row {
    width: 128.5714285714%;
    margin-left: -14.2857142857%;
  }

  .hex-grid-xs-2 .hex-col {
    width: 66.6666666667%;
    padding-bottom: 39.3650793651%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 350px) {
  .hex-grid-xs-2 .hex-row {
    padding-bottom: 25.306122449%;
  }

  .hex-grid-xs-2 .hex-col {
    padding-bottom: 19.6825396825%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xs-2 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xs-2 .hex-col:nth-child(2n+2) {
    margin-left: 33.3333333333%;
  }

  .hex-grid-xs-2 .hex-col:nth-child(2n+1) {
    margin-right: 33.3333333333%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 350px) {
  .hex-grid-xs-3 .hex-row {
    width: 120%;
    margin-left: -10%;
  }

  .hex-grid-xs-3 .hex-col {
    width: 50%;
    padding-bottom: 29.5238095238%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 350px) {
  .hex-grid-xs-3 .hex-row {
    padding-bottom: 17.7142857143%;
  }

  .hex-grid-xs-3 .hex-col {
    padding-bottom: 14.7619047619%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xs-3 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xs-3 .hex-col:nth-child(3n+3) {
    margin-left: 25%;
  }

  .hex-grid-xs-3 .hex-col:nth-child(3n+3) {
    margin-right: 25%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 350px) {
  .hex-grid-xs-4 .hex-row {
    width: 115.3846153846%;
    margin-left: -7.6923076923%;
  }

  .hex-grid-xs-4 .hex-col {
    width: 40%;
    padding-bottom: 23.619047619%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 350px) {
  .hex-grid-xs-4 .hex-row {
    padding-bottom: 13.6263736264%;
  }

  .hex-grid-xs-4 .hex-col {
    padding-bottom: 11.8095238095%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xs-4 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xs-4 .hex-col:nth-child(4n+3) {
    margin-left: 20%;
  }

  .hex-grid-xs-4 .hex-col:nth-child(4n+2) {
    margin-right: 20%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 350px) {
  .hex-grid-xs-5 .hex-row {
    width: 112.5%;
    margin-left: -6.25%;
  }

  .hex-grid-xs-5 .hex-col {
    width: 33.3333333333%;
    padding-bottom: 19.6825396825%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 350px) {
  .hex-grid-xs-5 .hex-row {
    padding-bottom: 11.0714285714%;
  }

  .hex-grid-xs-5 .hex-col {
    padding-bottom: 9.8412698413%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xs-5 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xs-5 .hex-col:nth-child(5n+4) {
    margin-left: 16.6666666667%;
  }

  .hex-grid-xs-5 .hex-col:nth-child(5n+5) {
    margin-right: 16.6666666667%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 350px) {
  .hex-grid-xs-6 .hex-row {
    width: 110.5263157895%;
    margin-left: -5.2631578947%;
  }

  .hex-grid-xs-6 .hex-col {
    width: 28.5714285714%;
    padding-bottom: 16.8707482993%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 350px) {
  .hex-grid-xs-6 .hex-row {
    padding-bottom: 9.3233082707%;
  }

  .hex-grid-xs-6 .hex-col {
    padding-bottom: 8.4353741497%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xs-6 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xs-6 .hex-col:nth-child(6n+4) {
    margin-left: 14.2857142857%;
  }

  .hex-grid-xs-6 .hex-col:nth-child(6n+3) {
    margin-right: 14.2857142857%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 350px) {
  .hex-grid-xs-7 .hex-row {
    width: 109.0909090909%;
    margin-left: -4.5454545455%;
  }

  .hex-grid-xs-7 .hex-col {
    width: 25%;
    padding-bottom: 14.7619047619%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 350px) {
  .hex-grid-xs-7 .hex-row {
    padding-bottom: 8.0519480519%;
  }

  .hex-grid-xs-7 .hex-col {
    padding-bottom: 7.380952381%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xs-7 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xs-7 .hex-col:nth-child(7n+5) {
    margin-left: 12.5%;
  }

  .hex-grid-xs-7 .hex-col:nth-child(7n+7) {
    margin-right: 12.5%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 350px) {
  .hex-grid-xs-8 .hex-row {
    width: 108%;
    margin-left: -4%;
  }

  .hex-grid-xs-8 .hex-col {
    width: 22.2222222222%;
    padding-bottom: 13.1216931217%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 350px) {
  .hex-grid-xs-8 .hex-row {
    padding-bottom: 7.0857142857%;
  }

  .hex-grid-xs-8 .hex-col {
    padding-bottom: 6.5608465608%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xs-8 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xs-8 .hex-col:nth-child(8n+5) {
    margin-left: 11.1111111111%;
  }

  .hex-grid-xs-8 .hex-col:nth-child(8n+4) {
    margin-right: 11.1111111111%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 350px) {
  .hex-grid-xs-9 .hex-row {
    width: 107.1428571429%;
    margin-left: -3.5714285714%;
  }

  .hex-grid-xs-9 .hex-col {
    width: 20%;
    padding-bottom: 11.8095238095%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 350px) {
  .hex-grid-xs-9 .hex-row {
    padding-bottom: 6.3265306122%;
  }

  .hex-grid-xs-9 .hex-col {
    padding-bottom: 5.9047619048%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xs-9 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xs-9 .hex-col:nth-child(9n+6) {
    margin-left: 10%;
  }

  .hex-grid-xs-9 .hex-col:nth-child(9n+9) {
    margin-right: 10%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 350px) {
  .hex-grid-xs-10 .hex-row {
    width: 106.4516129032%;
    margin-left: -3.2258064516%;
  }

  .hex-grid-xs-10 .hex-col {
    width: 18.1818181818%;
    padding-bottom: 10.7359307359%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 350px) {
  .hex-grid-xs-10 .hex-row {
    padding-bottom: 5.7142857143%;
  }

  .hex-grid-xs-10 .hex-col {
    padding-bottom: 5.367965368%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xs-10 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xs-10 .hex-col:nth-child(10n+6) {
    margin-left: 9.0909090909%;
  }

  .hex-grid-xs-10 .hex-col:nth-child(10n+5) {
    margin-right: 9.0909090909%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 350px) {
  .hex-grid-xs-11 .hex-row {
    width: 105.8823529412%;
    margin-left: -2.9411764706%;
  }

  .hex-grid-xs-11 .hex-col {
    width: 16.6666666667%;
    padding-bottom: 9.8412698413%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 350px) {
  .hex-grid-xs-11 .hex-row {
    padding-bottom: 5.2100840336%;
  }

  .hex-grid-xs-11 .hex-col {
    padding-bottom: 4.9206349206%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xs-11 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xs-11 .hex-col:nth-child(11n+7) {
    margin-left: 8.3333333333%;
  }

  .hex-grid-xs-11 .hex-col:nth-child(11n+11) {
    margin-right: 8.3333333333%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 350px) {
  .hex-grid-xs-12 .hex-row {
    width: 105.4054054054%;
    margin-left: -2.7027027027%;
  }

  .hex-grid-xs-12 .hex-col {
    width: 15.3846153846%;
    padding-bottom: 9.0842490842%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 350px) {
  .hex-grid-xs-12 .hex-row {
    padding-bottom: 4.7876447876%;
  }

  .hex-grid-xs-12 .hex-col {
    padding-bottom: 4.5421245421%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xs-12 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xs-12 .hex-col:nth-child(12n+7) {
    margin-left: 7.6923076923%;
  }

  .hex-grid-xs-12 .hex-col:nth-child(12n+6) {
    margin-right: 7.6923076923%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 544px) {
  .hex-grid-sm-1 .hex-row {
    width: 150%;
    margin-left: -25%;
  }

  .hex-grid-sm-1 .hex-col {
    width: 100%;
    padding-bottom: 59.0476190476%;
  }
}

/*== Grid CSS 3: More than one colum case */
/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 544px) {
  .hex-grid-sm-2 .hex-row {
    width: 128.5714285714%;
    margin-left: -14.2857142857%;
  }

  .hex-grid-sm-2 .hex-col {
    width: 66.6666666667%;
    padding-bottom: 39.3650793651%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 544px) {
  .hex-grid-sm-2 .hex-row {
    padding-bottom: 25.306122449%;
  }

  .hex-grid-sm-2 .hex-col {
    padding-bottom: 19.6825396825%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-sm-2 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-sm-2 .hex-col:nth-child(2n+2) {
    margin-left: 33.3333333333%;
  }

  .hex-grid-sm-2 .hex-col:nth-child(2n+1) {
    margin-right: 33.3333333333%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 544px) {
  .hex-grid-sm-3 .hex-row {
    width: 120%;
    margin-left: -10%;
  }

  .hex-grid-sm-3 .hex-col {
    width: 50%;
    padding-bottom: 29.5238095238%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 544px) {
  .hex-grid-sm-3 .hex-row {
    padding-bottom: 17.7142857143%;
  }

  .hex-grid-sm-3 .hex-col {
    padding-bottom: 14.7619047619%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-sm-3 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-sm-3 .hex-col:nth-child(3n+3) {
    margin-left: 25%;
  }

  .hex-grid-sm-3 .hex-col:nth-child(3n+3) {
    margin-right: 25%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 544px) {
  .hex-grid-sm-4 .hex-row {
    width: 115.3846153846%;
    margin-left: -7.6923076923%;
  }

  .hex-grid-sm-4 .hex-col {
    width: 40%;
    padding-bottom: 23.619047619%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 544px) {
  .hex-grid-sm-4 .hex-row {
    padding-bottom: 13.6263736264%;
  }

  .hex-grid-sm-4 .hex-col {
    padding-bottom: 11.8095238095%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-sm-4 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-sm-4 .hex-col:nth-child(4n+3) {
    margin-left: 20%;
  }

  .hex-grid-sm-4 .hex-col:nth-child(4n+2) {
    margin-right: 20%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 544px) {
  .hex-grid-sm-5 .hex-row {
    width: 112.5%;
    margin-left: -6.25%;
  }

  .hex-grid-sm-5 .hex-col {
    width: 33.3333333333%;
    padding-bottom: 19.6825396825%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 544px) {
  .hex-grid-sm-5 .hex-row {
    padding-bottom: 11.0714285714%;
  }

  .hex-grid-sm-5 .hex-col {
    padding-bottom: 9.8412698413%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-sm-5 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-sm-5 .hex-col:nth-child(5n+4) {
    margin-left: 16.6666666667%;
  }

  .hex-grid-sm-5 .hex-col:nth-child(5n+5) {
    margin-right: 16.6666666667%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 544px) {
  .hex-grid-sm-6 .hex-row {
    width: 110.5263157895%;
    margin-left: -5.2631578947%;
  }

  .hex-grid-sm-6 .hex-col {
    width: 28.5714285714%;
    padding-bottom: 16.8707482993%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 544px) {
  .hex-grid-sm-6 .hex-row {
    padding-bottom: 9.3233082707%;
  }

  .hex-grid-sm-6 .hex-col {
    padding-bottom: 8.4353741497%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-sm-6 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-sm-6 .hex-col:nth-child(6n+4) {
    margin-left: 14.2857142857%;
  }

  .hex-grid-sm-6 .hex-col:nth-child(6n+3) {
    margin-right: 14.2857142857%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 544px) {
  .hex-grid-sm-7 .hex-row {
    width: 109.0909090909%;
    margin-left: -4.5454545455%;
  }

  .hex-grid-sm-7 .hex-col {
    width: 25%;
    padding-bottom: 14.7619047619%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 544px) {
  .hex-grid-sm-7 .hex-row {
    padding-bottom: 8.0519480519%;
  }

  .hex-grid-sm-7 .hex-col {
    padding-bottom: 7.380952381%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-sm-7 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-sm-7 .hex-col:nth-child(7n+5) {
    margin-left: 12.5%;
  }

  .hex-grid-sm-7 .hex-col:nth-child(7n+7) {
    margin-right: 12.5%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 544px) {
  .hex-grid-sm-8 .hex-row {
    width: 108%;
    margin-left: -4%;
  }

  .hex-grid-sm-8 .hex-col {
    width: 22.2222222222%;
    padding-bottom: 13.1216931217%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 544px) {
  .hex-grid-sm-8 .hex-row {
    padding-bottom: 7.0857142857%;
  }

  .hex-grid-sm-8 .hex-col {
    padding-bottom: 6.5608465608%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-sm-8 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-sm-8 .hex-col:nth-child(8n+5) {
    margin-left: 11.1111111111%;
  }

  .hex-grid-sm-8 .hex-col:nth-child(8n+4) {
    margin-right: 11.1111111111%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 544px) {
  .hex-grid-sm-9 .hex-row {
    width: 107.1428571429%;
    margin-left: -3.5714285714%;
  }

  .hex-grid-sm-9 .hex-col {
    width: 20%;
    padding-bottom: 11.8095238095%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 544px) {
  .hex-grid-sm-9 .hex-row {
    padding-bottom: 6.3265306122%;
  }

  .hex-grid-sm-9 .hex-col {
    padding-bottom: 5.9047619048%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-sm-9 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-sm-9 .hex-col:nth-child(9n+6) {
    margin-left: 10%;
  }

  .hex-grid-sm-9 .hex-col:nth-child(9n+9) {
    margin-right: 10%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 544px) {
  .hex-grid-sm-10 .hex-row {
    width: 106.4516129032%;
    margin-left: -3.2258064516%;
  }

  .hex-grid-sm-10 .hex-col {
    width: 18.1818181818%;
    padding-bottom: 10.7359307359%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 544px) {
  .hex-grid-sm-10 .hex-row {
    padding-bottom: 5.7142857143%;
  }

  .hex-grid-sm-10 .hex-col {
    padding-bottom: 5.367965368%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-sm-10 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-sm-10 .hex-col:nth-child(10n+6) {
    margin-left: 9.0909090909%;
  }

  .hex-grid-sm-10 .hex-col:nth-child(10n+5) {
    margin-right: 9.0909090909%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 544px) {
  .hex-grid-sm-11 .hex-row {
    width: 105.8823529412%;
    margin-left: -2.9411764706%;
  }

  .hex-grid-sm-11 .hex-col {
    width: 16.6666666667%;
    padding-bottom: 9.8412698413%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 544px) {
  .hex-grid-sm-11 .hex-row {
    padding-bottom: 5.2100840336%;
  }

  .hex-grid-sm-11 .hex-col {
    padding-bottom: 4.9206349206%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-sm-11 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-sm-11 .hex-col:nth-child(11n+7) {
    margin-left: 8.3333333333%;
  }

  .hex-grid-sm-11 .hex-col:nth-child(11n+11) {
    margin-right: 8.3333333333%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 544px) {
  .hex-grid-sm-12 .hex-row {
    width: 105.4054054054%;
    margin-left: -2.7027027027%;
  }

  .hex-grid-sm-12 .hex-col {
    width: 15.3846153846%;
    padding-bottom: 9.0842490842%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 544px) {
  .hex-grid-sm-12 .hex-row {
    padding-bottom: 4.7876447876%;
  }

  .hex-grid-sm-12 .hex-col {
    padding-bottom: 4.5421245421%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-sm-12 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-sm-12 .hex-col:nth-child(12n+7) {
    margin-left: 7.6923076923%;
  }

  .hex-grid-sm-12 .hex-col:nth-child(12n+6) {
    margin-right: 7.6923076923%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 768px) {
  .hex-grid-md-1 .hex-row {
    width: 150%;
    margin-left: -25%;
  }

  .hex-grid-md-1 .hex-col {
    width: 100%;
    padding-bottom: 59.0476190476%;
  }
}

/*== Grid CSS 3: More than one colum case */
/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 768px) {
  .hex-grid-md-2 .hex-row {
    width: 128.5714285714%;
    margin-left: -14.2857142857%;
  }

  .hex-grid-md-2 .hex-col {
    width: 66.6666666667%;
    padding-bottom: 39.3650793651%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 768px) {
  .hex-grid-md-2 .hex-row {
    padding-bottom: 25.306122449%;
  }

  .hex-grid-md-2 .hex-col {
    padding-bottom: 19.6825396825%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-md-2 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-md-2 .hex-col:nth-child(2n+2) {
    margin-left: 33.3333333333%;
  }

  .hex-grid-md-2 .hex-col:nth-child(2n+1) {
    margin-right: 33.3333333333%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 768px) {
  .hex-grid-md-3 .hex-row {
    width: 120%;
    margin-left: -10%;
  }

  .hex-grid-md-3 .hex-col {
    width: 50%;
    padding-bottom: 29.5238095238%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 768px) {
  .hex-grid-md-3 .hex-row {
    padding-bottom: 17.7142857143%;
  }

  .hex-grid-md-3 .hex-col {
    padding-bottom: 14.7619047619%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-md-3 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-md-3 .hex-col:nth-child(3n+3) {
    margin-left: 25%;
  }

  .hex-grid-md-3 .hex-col:nth-child(3n+3) {
    margin-right: 25%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 768px) {
  .hex-grid-md-4 .hex-row {
    width: 115.3846153846%;
    margin-left: -7.6923076923%;
  }

  .hex-grid-md-4 .hex-col {
    width: 40%;
    padding-bottom: 23.619047619%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 768px) {
  .hex-grid-md-4 .hex-row {
    padding-bottom: 13.6263736264%;
  }

  .hex-grid-md-4 .hex-col {
    padding-bottom: 11.8095238095%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-md-4 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-md-4 .hex-col:nth-child(4n+3) {
    margin-left: 20%;
  }

  .hex-grid-md-4 .hex-col:nth-child(4n+2) {
    margin-right: 20%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 768px) {
  .hex-grid-md-5 .hex-row {
    width: 180vw;
    margin-left: -40%;
    margin-top: -20%;
  }

  .hex-grid-md-5 .hex-col {
    width: 40%;
    padding-bottom: 19.6825396825%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 768px) {
  .hex-grid-md-5 .hex-row {
    padding-bottom: 0;
    /* overflow: hidden;*/
  }

  .hex-grid-md-5 .hex-col {
    padding-bottom: 11.84127%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-md-5 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-md-5 .hex-col:nth-child(5n+4) {
    /* margin-left: 16.6666666667%; */
  }

  .hex-grid-md-5 .hex-col:nth-child(5n+5) {
    /* margin-right: 16.6666666667%; */
    margin-right: auto;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 768px) {
  .hex-grid-md-6 .hex-row {
    width: 110.5263157895%;
    margin-left: -5.2631578947%;
  }

  .hex-grid-md-6 .hex-col {
    width: 28.5714285714%;
    padding-bottom: 16.8707482993%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 768px) {
  .hex-grid-md-6 .hex-row {
    padding-bottom: 9.3233082707%;
  }

  .hex-grid-md-6 .hex-col {
    padding-bottom: 8.4353741497%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-md-6 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-md-6 .hex-col:nth-child(6n+4) {
    margin-left: 14.2857142857%;
  }

  .hex-grid-md-6 .hex-col:nth-child(6n+3) {
    margin-right: 14.2857142857%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 768px) {
  .hex-grid-md-7 .hex-row {
    width: 109.0909090909%;
    margin-left: -4.5454545455%;
  }

  .hex-grid-md-7 .hex-col {
    width: 25%;
    padding-bottom: 14.7619047619%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 768px) {
  .hex-grid-md-7 .hex-row {
    padding-bottom: 8.0519480519%;
  }

  .hex-grid-md-7 .hex-col {
    padding-bottom: 7.380952381%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-md-7 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-md-7 .hex-col:nth-child(7n+5) {
    margin-left: 12.5%;
  }

  .hex-grid-md-7 .hex-col:nth-child(7n+7) {
    margin-right: 12.5%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 768px) {
  .hex-grid-md-8 .hex-row {
    width: 108%;
    margin-left: -4%;
  }

  .hex-grid-md-8 .hex-col {
    width: 22.2222222222%;
    padding-bottom: 13.1216931217%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 768px) {
  .hex-grid-md-8 .hex-row {
    padding-bottom: 7.0857142857%;
  }

  .hex-grid-md-8 .hex-col {
    padding-bottom: 6.5608465608%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-md-8 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-md-8 .hex-col:nth-child(8n+5) {
    margin-left: 11.1111111111%;
  }

  .hex-grid-md-8 .hex-col:nth-child(8n+4) {
    margin-right: 11.1111111111%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 768px) {
  .hex-grid-md-9 .hex-row {
    width: 107.1428571429%;
    margin-left: -3.5714285714%;
  }

  .hex-grid-md-9 .hex-col {
    width: 20%;
    padding-bottom: 11.8095238095%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 768px) {
  .hex-grid-md-9 .hex-row {
    padding-bottom: 6.3265306122%;
  }

  .hex-grid-md-9 .hex-col {
    padding-bottom: 5.9047619048%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-md-9 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-md-9 .hex-col:nth-child(9n+6) {
    margin-left: 10%;
  }

  .hex-grid-md-9 .hex-col:nth-child(9n+9) {
    margin-right: 10%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 768px) {
  .hex-grid-md-10 .hex-row {
    width: 106.4516129032%;
    margin-left: -3.2258064516%;
  }

  .hex-grid-md-10 .hex-col {
    width: 18.1818181818%;
    padding-bottom: 10.7359307359%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 768px) {
  .hex-grid-md-10 .hex-row {
    padding-bottom: 5.7142857143%;
  }

  .hex-grid-md-10 .hex-col {
    padding-bottom: 5.367965368%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-md-10 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-md-10 .hex-col:nth-child(10n+6) {
    margin-left: 9.0909090909%;
  }

  .hex-grid-md-10 .hex-col:nth-child(10n+5) {
    margin-right: 9.0909090909%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 768px) {
  .hex-grid-md-11 .hex-row {
    width: 105.8823529412%;
    margin-left: -2.9411764706%;
  }

  .hex-grid-md-11 .hex-col {
    width: 16.6666666667%;
    padding-bottom: 9.8412698413%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 768px) {
  .hex-grid-md-11 .hex-row {
    padding-bottom: 5.2100840336%;
  }

  .hex-grid-md-11 .hex-col {
    padding-bottom: 4.9206349206%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-md-11 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-md-11 .hex-col:nth-child(11n+7) {
    margin-left: 8.3333333333%;
  }

  .hex-grid-md-11 .hex-col:nth-child(11n+11) {
    margin-right: 8.3333333333%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 768px) {
  .hex-grid-md-12 .hex-row {
    width: 105.4054054054%;
    margin-left: -2.7027027027%;
  }

  .hex-grid-md-12 .hex-col {
    width: 15.3846153846%;
    padding-bottom: 9.0842490842%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 768px) {
  .hex-grid-md-12 .hex-row {
    padding-bottom: 4.7876447876%;
  }

  .hex-grid-md-12 .hex-col {
    padding-bottom: 4.5421245421%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-md-12 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-md-12 .hex-col:nth-child(12n+7) {
    margin-left: 7.6923076923%;
  }

  .hex-grid-md-12 .hex-col:nth-child(12n+6) {
    margin-right: 7.6923076923%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 992px) {
  .hex-grid-lg-1 .hex-row {
    width: 150%;
    margin-left: -25%;
  }

  .hex-grid-lg-1 .hex-col {
    width: 100%;
    padding-bottom: 59.0476190476%;
  }
}

/*== Grid CSS 3: More than one colum case */
/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 992px) {
  .hex-grid-lg-2 .hex-row {
    width: 128.5714285714%;
    margin-left: -14.2857142857%;
  }

  .hex-grid-lg-2 .hex-col {
    width: 66.6666666667%;
    padding-bottom: 39.3650793651%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 992px) {
  .hex-grid-lg-2 .hex-row {
    padding-bottom: 25.306122449%;
  }

  .hex-grid-lg-2 .hex-col {
    padding-bottom: 19.6825396825%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-lg-2 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-lg-2 .hex-col:nth-child(2n+2) {
    margin-left: 33.3333333333%;
  }

  .hex-grid-lg-2 .hex-col:nth-child(2n+1) {
    margin-right: 33.3333333333%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 992px) {
  .hex-grid-lg-3 .hex-row {
    width: 120%;
    margin-left: -10%;
  }

  .hex-grid-lg-3 .hex-col {
    width: 50%;
    padding-bottom: 29.5238095238%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 992px) {
  .hex-grid-lg-3 .hex-row {
    padding-bottom: 17.7142857143%;
  }

  .hex-grid-lg-3 .hex-col {
    padding-bottom: 14.7619047619%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-lg-3 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-lg-3 .hex-col:nth-child(3n+3) {
    margin-left: 25%;
  }

  .hex-grid-lg-3 .hex-col:nth-child(3n+3) {
    margin-right: 25%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 992px) {
  .hex-grid-lg-4 .hex-row {
    width: 115.3846153846%;
    margin-left: -7.6923076923%;
  }

  .hex-grid-lg-4 .hex-col {
    width: 40%;
    padding-bottom: 23.619047619%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 992px) {
  .hex-grid-lg-4 .hex-row {
    padding-bottom: 13.6263736264%;
  }

  .hex-grid-lg-4 .hex-col {
    padding-bottom: 11.8095238095%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-lg-4 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-lg-4 .hex-col:nth-child(4n+3) {
    margin-left: 20%;
  }

  .hex-grid-lg-4 .hex-col:nth-child(4n+2) {
    margin-right: 20%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 992px) {
  .hex-grid-lg-5 .hex-row {
    width: 112.5%;
    margin-left: -6.25%;
  }

  .hex-grid-lg-5 .hex-col {
    width: 33.3333333333%;
    padding-bottom: 19.6825396825%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 992px) {
  .hex-grid-lg-5 .hex-row {
    padding-bottom: 11.0714285714%;
  }

  .hex-grid-lg-5 .hex-col {
    padding-bottom: 9.8412698413%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-lg-5 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-lg-5 .hex-col:nth-child(5n+4) {
    margin-left: 16.6666666667%;
  }

  .hex-grid-lg-5 .hex-col:nth-child(5n+5) {
    margin-right: 16.6666666667%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 992px) {
  .hex-grid-lg-6 .hex-row {
    width: 110.5263157895%;
    margin-left: -5.2631578947%;
  }

  .hex-grid-lg-6 .hex-col {
    width: 28.5714285714%;
    padding-bottom: 16.8707482993%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 992px) {
  .hex-grid-lg-6 .hex-row {
    padding-bottom: 9.3233082707%;
  }

  .hex-grid-lg-6 .hex-col {
    padding-bottom: 8.4353741497%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-lg-6 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-lg-6 .hex-col:nth-child(6n+4) {
    margin-left: 14.2857142857%;
  }

  .hex-grid-lg-6 .hex-col:nth-child(6n+3) {
    margin-right: 14.2857142857%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 992px) {
  .hex-grid-lg-7 .hex-row {
    width: 109.0909090909%;
    margin-left: -4.5454545455%;
  }

  .hex-grid-lg-7 .hex-col {
    width: 25%;
    padding-bottom: 14.7619047619%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 992px) {
  .hex-grid-lg-7 .hex-row {
    padding-bottom: 8.0519480519%;
  }

  .hex-grid-lg-7 .hex-col {
    padding-bottom: 7.380952381%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-lg-7 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-lg-7 .hex-col:nth-child(7n+5) {
    margin-left: 12.5%;
  }

  .hex-grid-lg-7 .hex-col:nth-child(7n+7) {
    margin-right: 12.5%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 992px) {
  .hex-grid-lg-8 .hex-row {
    width: 108%;
    margin-left: -4%;
  }

  .hex-grid-lg-8 .hex-col {
    width: 22.2222222222%;
    padding-bottom: 13.1216931217%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 992px) {
  .hex-grid-lg-8 .hex-row {
    padding-bottom: 7.0857142857%;
  }

  .hex-grid-lg-8 .hex-col {
    padding-bottom: 6.5608465608%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-lg-8 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-lg-8 .hex-col:nth-child(8n+5) {
    margin-left: 11.1111111111%;
  }

  .hex-grid-lg-8 .hex-col:nth-child(8n+4) {
    margin-right: 11.1111111111%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 992px) {
  .hex-grid-lg-9 .hex-row {
    width: 107.1428571429%;
    margin-left: -3.5714285714%;
  }

  .hex-grid-lg-9 .hex-col {
    width: 20%;
    padding-bottom: 11.8095238095%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 992px) {
  .hex-grid-lg-9 .hex-row {
    padding-bottom: 6.3265306122%;
  }

  .hex-grid-lg-9 .hex-col {
    padding-bottom: 5.9047619048%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-lg-9 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-lg-9 .hex-col:nth-child(9n+6) {
    margin-left: 10%;
  }

  .hex-grid-lg-9 .hex-col:nth-child(9n+9) {
    margin-right: 10%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 992px) {
  .hex-grid-lg-10 .hex-row {
    width: 106.4516129032%;
    margin-left: -3.2258064516%;
  }

  .hex-grid-lg-10 .hex-col {
    width: 18.1818181818%;
    padding-bottom: 10.7359307359%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 992px) {
  .hex-grid-lg-10 .hex-row {
    padding-bottom: 5.7142857143%;
  }

  .hex-grid-lg-10 .hex-col {
    padding-bottom: 5.367965368%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-lg-10 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-lg-10 .hex-col:nth-child(10n+6) {
    margin-left: 9.0909090909%;
  }

  .hex-grid-lg-10 .hex-col:nth-child(10n+5) {
    margin-right: 9.0909090909%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 992px) {
  .hex-grid-lg-11 .hex-row {
    width: 105.8823529412%;
    margin-left: -2.9411764706%;
  }

  .hex-grid-lg-11 .hex-col {
    width: 16.6666666667%;
    padding-bottom: 9.8412698413%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 992px) {
  .hex-grid-lg-11 .hex-row {
    padding-bottom: 5.2100840336%;
  }

  .hex-grid-lg-11 .hex-col {
    padding-bottom: 4.9206349206%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-lg-11 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-lg-11 .hex-col:nth-child(11n+7) {
    margin-left: 8.3333333333%;
  }

  .hex-grid-lg-11 .hex-col:nth-child(11n+11) {
    margin-right: 8.3333333333%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 992px) {
  .hex-grid-lg-12 .hex-row {
    width: 105.4054054054%;
    margin-left: -2.7027027027%;
  }

  .hex-grid-lg-12 .hex-col {
    width: 15.3846153846%;
    padding-bottom: 9.0842490842%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 992px) {
  .hex-grid-lg-12 .hex-row {
    padding-bottom: 4.7876447876%;
  }

  .hex-grid-lg-12 .hex-col {
    padding-bottom: 4.5421245421%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-lg-12 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-lg-12 .hex-col:nth-child(12n+7) {
    margin-left: 7.6923076923%;
  }

  .hex-grid-lg-12 .hex-col:nth-child(12n+6) {
    margin-right: 7.6923076923%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 1200px) {
  .hex-grid-xl-1 .hex-row {
    width: 150%;
    margin-left: -25%;
  }

  .hex-grid-xl-1 .hex-col {
    width: 100%;
    padding-bottom: 59.0476190476%;
  }
}

/*== Grid CSS 3: More than one colum case */
/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 1200px) {
  .hex-grid-xl-2 .hex-row {
    width: 128.5714285714%;
    margin-left: -14.2857142857%;
  }

  .hex-grid-xl-2 .hex-col {
    width: 66.6666666667%;
    padding-bottom: 39.3650793651%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 1200px) {
  .hex-grid-xl-2 .hex-row {
    padding-bottom: 25.306122449%;
  }

  .hex-grid-xl-2 .hex-col {
    padding-bottom: 19.6825396825%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xl-2 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xl-2 .hex-col:nth-child(2n+2) {
    margin-left: 33.3333333333%;
  }

  .hex-grid-xl-2 .hex-col:nth-child(2n+1) {
    margin-right: 33.3333333333%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 1200px) {
  .hex-grid-xl-3 .hex-row {
    width: 120%;
    margin-left: -10%;
  }

  .hex-grid-xl-3 .hex-col {
    width: 50%;
    padding-bottom: 29.5238095238%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 1200px) {
  .hex-grid-xl-3 .hex-row {
    padding-bottom: 17.7142857143%;
  }

  .hex-grid-xl-3 .hex-col {
    padding-bottom: 14.7619047619%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xl-3 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xl-3 .hex-col:nth-child(3n+3) {
    margin-left: 25%;
  }

  .hex-grid-xl-3 .hex-col:nth-child(3n+3) {
    margin-right: 25%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 1200px) {
  .hex-grid-xl-4 .hex-row {
    width: 115.3846153846%;
    margin-left: -7.6923076923%;
  }

  .hex-grid-xl-4 .hex-col {
    width: 40%;
    padding-bottom: 23.619047619%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 1200px) {
  .hex-grid-xl-4 .hex-row {
    padding-bottom: 13.6263736264%;
  }

  .hex-grid-xl-4 .hex-col {
    padding-bottom: 11.8095238095%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xl-4 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xl-4 .hex-col:nth-child(4n+3) {
    margin-left: 20%;
  }

  .hex-grid-xl-4 .hex-col:nth-child(4n+2) {
    margin-right: 20%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 1200px) {
  .hex-grid-xl-5 .hex-row {
    width: 112.5%;
    margin-left: -6.25%;
  }

  .hex-grid-xl-5 .hex-col {
    width: 33.3333333333%;
    padding-bottom: 19.6825396825%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 1200px) {
  .hex-grid-xl-5 .hex-row {
    padding-bottom: 11.0714285714%;
  }

  .hex-grid-xl-5 .hex-col {
    padding-bottom: 9.8412698413%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xl-5 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xl-5 .hex-col:nth-child(5n+4) {
    margin-left: 16.6666666667%;
  }

  .hex-grid-xl-5 .hex-col:nth-child(5n+5) {
    margin-right: 16.6666666667%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 1200px) {
  .hex-grid-xl-6 .hex-row {
    width: 110.5263157895%;
    margin-left: -5.2631578947%;
  }

  .hex-grid-xl-6 .hex-col {
    width: 28.5714285714%;
    padding-bottom: 16.8707482993%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 1200px) {
  .hex-grid-xl-6 .hex-row {
    padding-bottom: 9.3233082707%;
  }

  .hex-grid-xl-6 .hex-col {
    padding-bottom: 8.4353741497%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xl-6 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xl-6 .hex-col:nth-child(6n+4) {
    margin-left: 14.2857142857%;
  }

  .hex-grid-xl-6 .hex-col:nth-child(6n+3) {
    margin-right: 14.2857142857%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 1200px) {
  .hex-grid-xl-7 .hex-row {
    width: 109.0909090909%;
    margin-left: -4.5454545455%;
  }

  .hex-grid-xl-7 .hex-col {
    width: 25%;
    padding-bottom: 14.7619047619%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 1200px) {
  .hex-grid-xl-7 .hex-row {
    padding-bottom: 8.0519480519%;
  }

  .hex-grid-xl-7 .hex-col {
    padding-bottom: 7.380952381%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xl-7 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xl-7 .hex-col:nth-child(7n+5) {
    margin-left: 12.5%;
  }

  .hex-grid-xl-7 .hex-col:nth-child(7n+7) {
    margin-right: 12.5%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 1200px) {
  .hex-grid-xl-8 .hex-row {
    width: 108%;
    margin-left: -4%;
  }

  .hex-grid-xl-8 .hex-col {
    width: 22.2222222222%;
    padding-bottom: 13.1216931217%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 1200px) {
  .hex-grid-xl-8 .hex-row {
    padding-bottom: 7.0857142857%;
  }

  .hex-grid-xl-8 .hex-col {
    padding-bottom: 6.5608465608%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xl-8 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xl-8 .hex-col:nth-child(8n+5) {
    margin-left: 11.1111111111%;
  }

  .hex-grid-xl-8 .hex-col:nth-child(8n+4) {
    margin-right: 11.1111111111%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 1200px) {
  .hex-grid-xl-9 .hex-row {
    width: 107.1428571429%;
    margin-left: -3.5714285714%;
  }

  .hex-grid-xl-9 .hex-col {
    width: 20%;
    padding-bottom: 11.8095238095%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 1200px) {
  .hex-grid-xl-9 .hex-row {
    padding-bottom: 6.3265306122%;
  }

  .hex-grid-xl-9 .hex-col {
    padding-bottom: 5.9047619048%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xl-9 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xl-9 .hex-col:nth-child(9n+6) {
    margin-left: 10%;
  }

  .hex-grid-xl-9 .hex-col:nth-child(9n+9) {
    margin-right: 10%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 1200px) {
  .hex-grid-xl-10 .hex-row {
    width: 106.4516129032%;
    margin-left: -3.2258064516%;
  }

  .hex-grid-xl-10 .hex-col {
    width: 18.1818181818%;
    padding-bottom: 10.7359307359%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 1200px) {
  .hex-grid-xl-10 .hex-row {
    padding-bottom: 5.7142857143%;
  }

  .hex-grid-xl-10 .hex-col {
    padding-bottom: 5.367965368%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xl-10 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xl-10 .hex-col:nth-child(10n+6) {
    margin-left: 9.0909090909%;
  }

  .hex-grid-xl-10 .hex-col:nth-child(10n+5) {
    margin-right: 9.0909090909%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 1200px) {
  .hex-grid-xl-11 .hex-row {
    width: 105.8823529412%;
    margin-left: -2.9411764706%;
  }

  .hex-grid-xl-11 .hex-col {
    width: 16.6666666667%;
    padding-bottom: 9.8412698413%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 1200px) {
  .hex-grid-xl-11 .hex-row {
    padding-bottom: 5.2100840336%;
  }

  .hex-grid-xl-11 .hex-col {
    padding-bottom: 4.9206349206%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xl-11 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xl-11 .hex-col:nth-child(11n+7) {
    margin-left: 8.3333333333%;
  }

  .hex-grid-xl-11 .hex-col:nth-child(11n+11) {
    margin-right: 8.3333333333%;
  }
}

/* This allows us to initialize the mobile first case without col-* suffix  */
/*= Math that changes depending on the amount of cols */
/* calculation of the amount of hexagons on first and second row */
/* using modulo to find out if total amount is odd or even */
/* Calculate the position of the extra offset margins*/
/* Amount of grid dividers in one row. Each .hex-col is divided into 6 subcolumns */
/* calculation of the divider width
  The divider with is used to find out the width of the .hex-row wrapper relative to the Bootstrap .container.  
  All dividers summed together are always > 100% because two dividers are in the invisible space on the left and right. e.g 120% in case of 12 dividers*/
/* .hex-col width within the .hex-row. 
  All col width within a row sum up to 100% because we change the reference system here. */
/*== Grid CSS 2: Mobile first and col 1 case*/
@media (min-width: 1200px) {
  .hex-grid-xl-12 .hex-row {
    width: 105.4054054054%;
    margin-left: -2.7027027027%;
  }

  .hex-grid-xl-12 .hex-col {
    width: 15.3846153846%;
    padding-bottom: 9.0842490842%;
  }
}

/*== Grid CSS 3: More than one colum case */
@media (min-width: 1200px) {
  .hex-grid-xl-12 .hex-row {
    padding-bottom: 4.7876447876%;
  }

  .hex-grid-xl-12 .hex-col {
    padding-bottom: 4.5421245421%;
    /* Extra offset margins (no margin if just one grid col)*/
    /* The first rule is dirty, but i need an stronger selector on each breakpoint */
  }

  .hex-grid-xl-12 .hex-col:nth-child(1n+1) {
    margin-left: 0;
    margin-right: 0;
  }

  .hex-grid-xl-12 .hex-col:nth-child(12n+7) {
    margin-left: 7.6923076923%;
  }

  .hex-grid-xl-12 .hex-col:nth-child(12n+6) {
    margin-right: 7.6923076923%;
  }
}

/*###
  Debug colors 
  ### */
/*###
  Formatting the hexagons -> idependent of grid 
  ### */
#hex-polygon-shared,
#hex-mask-shared {
  position: absolute;
  left: -10000px;
  top: 0;
  width: 0;
  height: 0;
}

.hex-polygon-shared polygon.hex-polygon {
  fill: inherit;
  stroke: inherit;
}

.hex-svg use.hex-polygon {
  stroke: #8A9B79;
  fill: #8A9B79;
}

#hex-mask-shared use.hex-polygon {
  stroke: white;
  fill: white;
}

.hex-wrapper .hex-svg {
  position: absolute;
  top: 0;
  left: 0;
  width: 100%;
  height: 100%;
}

.hex-wrapper .hex-content {
  color: #0A3F39;
  position: absolute;
  /* centring trick*/
  top: 80px;
  left: 50%;
  transform: translate(-50%, 0);
  -webkit-transform: translate(-50%, 0);
  text-align: center;
  font-size: 1.2vw;
  width: 56%;
  z-index: 99;
}

.hex-wrapper .hex-content p {
  margin-bottom: 10px;
}

.hex-wrapper .hex-content.hex-logo-div {
  color: #0A3F39;
  position: absolute;
  top: 50%;
  left: 50%;
  transform: translate(-50%, -50%);
  -webkit-transform: translate(-50%, -50%);
  text-align: center;

}

.hex-wrapper .hex-content h3,
.hex-wrapper .hex-content h2 {
  font-family: 'Bauhaus Std';
  font-weight: 500;
  font-size: 2.2vw;
  margin-bottom: 20px;
}

.our-h2 {
  font-size: 3vw;
  font-family: 'Bauhaus Std';
  font-weight: 500;
  color: #0A3F39;
  text-align: center;
  margin-top: -30px
}

ul.hex-cont-list {
  display: flex;
  flex-wrap: wrap;
  padding: 0;
  list-style: none;
  justify-content: start;
  text-align: left;
  row-gap: 14px;
  column-gap: 5%;
}

ul.hex-cont-list li {
  flex: 1;
  flex-basis: 45%;
  display: flex;
  align-items: self-start;
  column-gap: 5px;
  font-size: 1vw;
}

ul.hex-cont-list.one-row li {
  flex-basis: 100%;
  column-gap: 0;
  justify-content: center;
}

ul.hex-cont-list.one-row li span {
  flex-basis: 18px;
  margin-right: 5px
}

ul.hex-cont-list li span {
  flex: none;
  flex-basis: 18px;
  margin-right: 5px
}

ul.hex-cont-list.compare-prices li {
  flex: 1;
  display: flex;
  flex-direction: column;
  justify-content: center;
  text-align: center;
  align-items: center;
}

ul.hex-cont-list.compare-prices li span {
  margin-bottom: 5px
}

ul.hex-cont-list.compare-prices li a {
  font-size: .8vw;
  color: #0A3F39;
  text-decoration: none;
  margin-top: 10px;
}

ul.hex-cont-list.mobile-app {

  row-gap: 0;
  column-gap: 10px;
  align-items: start;
  justify-content: space-between;
  width: 230px;
  flex-wrap: nowrap;
  margin: 20px auto;
}

ul.hex-cont-list.mobile-app li {
  flex: 1;
  column-gap: 0;
}

ul.hex-cont-list.mobile-app li img {
  width: auto;
  height: 35px;
}

.hex-wrapper .hex-boxlink {
  position: absolute;
  display: block;
  top: 8.8571428571px;
  bottom: 8.8571428571px;
  left: 10px;
  right: 10px;
  border-radius: 100%;
  z-index: 10;
  background-image: url("about:blank");
}

.hex-wrapper .hex-bg {
  fill: #ffffff;
}

.hex-wrapper .hex-bg.light {
  fill: #f9f7f5
}

.hex-wrapper .hex-bg.blank {
  fill: transparent
}

.hex-desktop {
  display: block !important;
}

.hex-mobile {
  display: none !important;
}

.hidden {
  opacity: 0;
}


.center-logo {
  /* text-align: center;
  margin-top: 6%;
  z-index: 9;
  position: relative;
  margin-bottom: -14%; */
}

.hex-logo-div {
  margin-top: 130px;
}

.font-contact {
  font-family: 'Bauhaus Std';
  font-weight: 300;
  font-size: 1.6vw;
  margin-bottom: 4vw;
}

ul.hex-cont-list.one-row.contact-details {
  width: 64%;
  margin: 0 auto;
}

ul.hex-cont-list.one-row.contact-details li {
  flex-direction: column;
  justify-content: center;
  align-items: center;
  gap: 5px;
  text-align: center;
  line-height: 1.4;
}

ul.hex-cont-list.one-row.contact-details li a {
  color: #0A3F39;
  text-decoration: none;
}

.container-hex {
  overflow: hidden;
  padding-top:50px
}



@media (min-width: 768px) {
  .hex-grid-md-5 .hex-col:nth-child(3) {
    margin-left: 20%;
  }

  .hex-grid-md-5 .hex-col:nth-child(7) {
    margin-left: 20%;
  }

  .hex-grid-md-5 .hex-col:nth-child(11) {
    margin-left: 20%;
  }

  .hex-grid-md-5 .hex-col:nth-child(15) {
    margin-left: 20%;
  }

}

@media (max-width:768px) {

  .hex-grid-xs-3 .hex-row {
    padding-bottom: 50px;
  }

  .hex-grid-xs-3 .hex-col {
    padding-bottom: 130%;
    width: 150%;
    margin-left: -25% !important;
  }

  .hex-col.our-team-div {
    margin-top:50px !important;
  }

  .hex-grid .hex-wrapper {
    left: 0;
    right: 0;
    padding-bottom: 100%;
  }

  .hex-grid-xs-3 .hex-col:nth-child(3n+3) {
    margin-right: 0;
  }

  .hex-grid-xs-3 .hex-col:nth-child(3n+3) {
    margin-left: 0;
  }

  .hex-logo-div {
    margin-top: -30px;
  }

  .m-hidden {
    display: none !important;
  }

  .m-top-logo {
    padding-bottom: 30px !important;
  }

  .hex-grid .hex-col {
    margin-top: 13px;
  }

  .hex-grid .m-top-logo .hex-wrapper {
    padding-bottom: 120px;
  }

  .hex-grid .m-top-logo .hex-wrapper .hex-content {
    width: 140px;
  }

  .hex-grid-xs-3 .hex-row {
    max-width: 480px;
    width: 100%;
    margin: 0 auto !important;
  }

  .hex-wrapper .hex-content h3 {
    font-size: 28px;
    margin-bottom: 20px;
    margin-top: 10px;
  }

  ul.hex-cont-list li {
    font-size: 10px;
  }

  ul.hex-cont-list {
    row-gap: 5px;
    column-gap: 5px;
  }

  .hex-wrapper .hex-content {
    top: 45px;
    font-size: 14px;
    width: 60%;
  }

  .font-contact {
    font-size: 20px;
    margin-bottom: 10px;
    padding-left: 18px;
    padding-right: 18px;
  }

  ul.hex-cont-list li span {
    margin-right: 0;
  }

  ul.hex-cont-list.one-row.contact-details {
    width: 94%;
  }

  ul.hex-cont-list.one-row.contact-details img {
    width: 15px;
  }

  ul.hex-cont-list.one-row.contact-details li {
    gap: 3px;
  }

  ul.hex-cont-list.mobile-app {
    width: 250px;
    margin: 10px auto;
  }

  ul.hex-cont-list.mobile-app li img {
    height: 36px;
  }

  .hex-pad {
    padding-bottom: 100% !important;
  }

  .our-h2 {
            margin-top: -20px;
        font-size: 8vw;
  }

  ul.hex-cont-list li {
    font-size: 18px;
  }
}

@media (max-width:480px) {
  .hex-wrapper .hex-content h3 {
    font-size: 25px;
    margin-bottom: 20px;
    margin-top: 10px;
  }

  .font-contact {
    font-size: 15px;
  }

  ul.hex-cont-list li {
    font-size: 15px;
  }
}


/*****************************************************************/

footer {
  padding: 40px 0;
}

footer.footer {
    margin-top: 30px;
}

.footer-link {
  /* display: flex;
  justify-content: space-between;
  max-width: 890px;
  margin: 0 auto;
  gap: 20px;
  /* Add space between items 
  flex-wrap: wrap;
  Optional if items should wrap on smaller screens */
}

ul,
li {
  list-style-type: none;
  margin: 0;
  padding: 0
}

ul.navbar-nav {
  /* font-size: 20px;
  font-family: 'Bauhaus Std';
  color: #0A3F39;
  text-align: center;
  display: flex;
  padding-top: 30px;
  justify-content: center;
      position: fixed;
    width: 100%;
    background: #ffffffab;
    z-index: 999;
    height: 86px;
    top:0 */
}

ul.navbar-nav li {
  /* padding: 0 20px; */
}

ul.navbar-nav li a {
  /* color: #0A3F39;
  text-decoration: none; */
}

ul.navbar-nav.nav-desktop {
  /* position: absolute;
  width: 100%;
  z-index: 1;
  top: 0 */
}

@media (max-width: 768px) {
  /* .footer-link {
    flex-direction: column;
    align-items: flex-start;
    /* Optional: aligns items to the left 
    gap: 30px;
    /* Space between stacked items 
    padding: 30px;
  } */
}


/* 
.footer-link ul {
  list-style-type: none;
  margin: 0;
  padding: 0;
  line-height: 38px;
}

.footer-link li {
  list-style-type: none;
  color: #0A3F39
}

.footer-link li a {
  color: #0A3F39;
  text-decoration: none
}

.footer-link h3 {
  font-family: 'Bauhaus Std';
  font-weight: 500;
  color: #0A3F39;
  margin-bottom: 10px;
  text-transform: uppercase;
    letter-spacing: 0.5px;
} */

ul.navbar-nav li span.place-button {
  color: #fff
}

.place-button a {
  padding: 10px 40px 10px;
  color: #fff !important;
  background-color: #5f8a6e;
  clip-path: polygon(10% 0%, 90% 0%, 100% 50%, 90% 100%, 11% 100%, 0% 50%);
}

.place-button a:hover {
    background-color: #386246;
}


/* Hamburger */
/* Hamburger Icon */
.hamburger {
  font-size: 30px;
  cursor: pointer;
  position: fixed;
  top: 20px;
  right: 20px;
  z-index: 100;
  display: none;
  color: #859875;
}

/* Slide Menu Styles */
.slide-menu {
  height: 100%;
  width: 0;
  position: fixed;
  top: 0;
  right: 0;
  background-color: #859875;
  overflow-x: hidden;
  transition: 0.3s;
  box-shadow: -2px 0 5px rgba(0, 0, 0, 0.2);
  z-index: 1000;
}

/* Close Button */
.slide-menu .close-btn {
  position: absolute;
  top: 20px;
  right: 25px;
  font-size: 36px;
  cursor: pointer;
}

/* Nav Styling Inside Menu */
.slide-menu ul {
  list-style: none;
  padding: 0;
}

.slide-menu li {
  margin: 20px 0;
}

.slide-menu a {
  text-decoration: none;
  font-size: 18px;
  color: #333;
  padding: 20px 20px 20px 20px;
}

.hex-drive {
  padding-top: 20px;
  line-height: 25px;
}

.hex-drive p {
  padding-bottom: 20px;
}

.hex-drive h3 {
  line-height: 30px;
}

.place-order-button {
  display: none;
}

.hex-mobile-logo {
  display: none;
}











/* Show hamburger only on mobile */
@media (max-width: 768px) {
  .hamburger {
    display: none;
  }

  .nav-desktop {
    display: none !important;
  }

  .slide-menu ul.navbar-nav {
    display: none;
  }

  .slide-menu ul.navbar-nav li a {
    color: #fff;
    padding: 10px 7px;
    display: block
  }

  .slide-menu li {
    padding: 0
  }

  .slide-menu .close-btn {
    position: absolute;
    top: 4px;
    right: 15px;
    font-size: 36px;
    cursor: pointer;
    color: #236439;
  }

  ul.navbar-nav {
    /* font-size: 14px;
    margin-bottom: 20px;
    padding-top: 20px;
    height: 56px; */
  }

  ul.navbar-nav li {
    /* padding: 0 10px; */
  }

  li.place-order-btn {
    display: none
  }

  .place-order-button {
    display: block;
    margin-top: 16px;
  }

  .place-button a {
    display: inline-block;
  }

  .hex-mobile-logo {
    display: block;
    margin-top: 60px;
  }

  .hex-col.m-top-logo {
    display: none;
  }

  header {
    text-align: center;
  }

  .hex-grid .hex-svg {
    padding: 10px;
  }

  .hex-mobile-logo img {
    width: 130px
  }

  .hex-drive {
    padding-top: 0;
    line-height: 20px;
  }

  footer {
    padding: 0 0 40px 0;
  }
}