/**
 *
 * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 * !! This file is a check-in from github!                       !!
 * !!                                                            !!
 * !! You should not modify this file directly. Instead:         !!
 * !! 1) Go to https://github.com/facebook/css-layout            !!
 * !! 2) Make a pull request and get it merged                   !!
 * !! 3) Copy the file from github to here                       !!
 * !!    (don't forget to keep this header)                      !!
 * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 * @generated
 *
 * Copyright (c) 2014, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 */

 #include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

 // in concatenated header, don't include Layout.h it's already at the top
 #ifndef CSS_LAYOUT_IMPLEMENTATION
 #include "Layout.h"
 #endif

 #ifdef _MSC_VER
 #include <float.h>
 #define isnan _isnan

 /* define fmaxf if < VC12 */
 #if _MSC_VER < 1800
 __forceinline const float fmaxf(const float a, const float b) {
   return (a > b) ? a : b;
 }
 #endif
 #endif

 bool isUndefined(float value) {
   return isnan(value);
 }

 static bool eq(float a, float b) {
   if (isUndefined(a)) {
     return isUndefined(b);
   }
   return fabs(a - b) < 0.0001;
 }

 void init_css_node(css_node_t *node) {
   node->style.align_items = CSS_ALIGN_STRETCH;
   node->style.align_content = CSS_ALIGN_FLEX_START;

   node->style.direction = CSS_DIRECTION_INHERIT;
   node->style.flex_direction = CSS_FLEX_DIRECTION_COLUMN;

   // Some of the fields default to undefined and not 0
   node->style.dimensions[CSS_WIDTH] = CSS_UNDEFINED;
   node->style.dimensions[CSS_HEIGHT] = CSS_UNDEFINED;

   node->style.minDimensions[CSS_WIDTH] = CSS_UNDEFINED;
   node->style.minDimensions[CSS_HEIGHT] = CSS_UNDEFINED;

   node->style.maxDimensions[CSS_WIDTH] = CSS_UNDEFINED;
   node->style.maxDimensions[CSS_HEIGHT] = CSS_UNDEFINED;

   node->style.position[CSS_LEFT] = CSS_UNDEFINED;
   node->style.position[CSS_TOP] = CSS_UNDEFINED;
   node->style.position[CSS_RIGHT] = CSS_UNDEFINED;
   node->style.position[CSS_BOTTOM] = CSS_UNDEFINED;

   node->style.margin[CSS_START] = CSS_UNDEFINED;
   node->style.margin[CSS_END] = CSS_UNDEFINED;
   node->style.padding[CSS_START] = CSS_UNDEFINED;
   node->style.padding[CSS_END] = CSS_UNDEFINED;
   node->style.border[CSS_START] = CSS_UNDEFINED;
   node->style.border[CSS_END] = CSS_UNDEFINED;

   node->layout.dimensions[CSS_WIDTH] = CSS_UNDEFINED;
   node->layout.dimensions[CSS_HEIGHT] = CSS_UNDEFINED;

   // Such that the comparison is always going to be false
   node->layout.last_requested_dimensions[CSS_WIDTH] = -1;
   node->layout.last_requested_dimensions[CSS_HEIGHT] = -1;
   node->layout.last_parent_max_width = -1;
   node->layout.last_parent_max_height = -1;
   node->layout.last_direction = (css_direction_t)-1;
   node->layout.should_update = true;
 }

 css_node_t *new_css_node() {
   css_node_t *node = (css_node_t *)calloc(1, sizeof(*node));
   init_css_node(node);
   return node;
 }

 void free_css_node(css_node_t *node) {
   free(node);
 }

 static void indent(int n) {
   for (int i = 0; i < n; ++i) {
     printf("  ");
   }
 }

 static void print_number_0(const char *str, float number) {
   if (!eq(number, 0)) {
     printf("%s: %g, ", str, number);
   }
 }

 static void print_number_nan(const char *str, float number) {
   if (!isnan(number)) {
     printf("%s: %g, ", str, number);
   }
 }

 static bool four_equal(float four[4]) {
   return
     eq(four[0], four[1]) &&
     eq(four[0], four[2]) &&
     eq(four[0], four[3]);
 }


 static void print_css_node_rec(
   css_node_t *node,
   css_print_options_t options,
   int level
 ) {
   indent(level);
   printf("{");

   if (node->print) {
     node->print(node->context);
   }

   if (options & CSS_PRINT_LAYOUT) {
     printf("layout: {");
     printf("width: %g, ", node->layout.dimensions[CSS_WIDTH]);
     printf("height: %g, ", node->layout.dimensions[CSS_HEIGHT]);
     printf("top: %g, ", node->layout.position[CSS_TOP]);
     printf("left: %g", node->layout.position[CSS_LEFT]);
     printf("}, ");
   }

   if (options & CSS_PRINT_STYLE) {
     if (node->style.flex_direction == CSS_FLEX_DIRECTION_COLUMN) {
       printf("flexDirection: 'column', ");
     } else if (node->style.flex_direction == CSS_FLEX_DIRECTION_COLUMN_REVERSE) {
       printf("flexDirection: 'columnReverse', ");
     } else if (node->style.flex_direction == CSS_FLEX_DIRECTION_ROW) {
       printf("flexDirection: 'row', ");
     } else if (node->style.flex_direction == CSS_FLEX_DIRECTION_ROW_REVERSE) {
       printf("flexDirection: 'rowReverse', ");
     }

     if (node->style.justify_content == CSS_JUSTIFY_CENTER) {
       printf("justifyContent: 'center', ");
     } else if (node->style.justify_content == CSS_JUSTIFY_FLEX_END) {
       printf("justifyContent: 'flex-end', ");
     } else if (node->style.justify_content == CSS_JUSTIFY_SPACE_AROUND) {
       printf("justifyContent: 'space-around', ");
     } else if (node->style.justify_content == CSS_JUSTIFY_SPACE_BETWEEN) {
       printf("justifyContent: 'space-between', ");
     }

     if (node->style.align_items == CSS_ALIGN_CENTER) {
       printf("alignItems: 'center', ");
     } else if (node->style.align_items == CSS_ALIGN_FLEX_END) {
       printf("alignItems: 'flex-end', ");
     } else if (node->style.align_items == CSS_ALIGN_STRETCH) {
       printf("alignItems: 'stretch', ");
     }

     if (node->style.align_content == CSS_ALIGN_CENTER) {
       printf("alignContent: 'center', ");
     } else if (node->style.align_content == CSS_ALIGN_FLEX_END) {
       printf("alignContent: 'flex-end', ");
     } else if (node->style.align_content == CSS_ALIGN_STRETCH) {
       printf("alignContent: 'stretch', ");
     }

     if (node->style.align_self == CSS_ALIGN_FLEX_START) {
       printf("alignSelf: 'flex-start', ");
     } else if (node->style.align_self == CSS_ALIGN_CENTER) {
       printf("alignSelf: 'center', ");
     } else if (node->style.align_self == CSS_ALIGN_FLEX_END) {
       printf("alignSelf: 'flex-end', ");
     } else if (node->style.align_self == CSS_ALIGN_STRETCH) {
       printf("alignSelf: 'stretch', ");
     }

     print_number_nan("flex", node->style.flex);

     if (four_equal(node->style.margin)) {
       print_number_0("margin", node->style.margin[CSS_LEFT]);
     } else {
       print_number_0("marginLeft", node->style.margin[CSS_LEFT]);
       print_number_0("marginRight", node->style.margin[CSS_RIGHT]);
       print_number_0("marginTop", node->style.margin[CSS_TOP]);
       print_number_0("marginBottom", node->style.margin[CSS_BOTTOM]);
       print_number_0("marginStart", node->style.margin[CSS_START]);
       print_number_0("marginEnd", node->style.margin[CSS_END]);
     }

     if (four_equal(node->style.padding)) {
       print_number_0("padding", node->style.margin[CSS_LEFT]);
     } else {
       print_number_0("paddingLeft", node->style.padding[CSS_LEFT]);
       print_number_0("paddingRight", node->style.padding[CSS_RIGHT]);
       print_number_0("paddingTop", node->style.padding[CSS_TOP]);
       print_number_0("paddingBottom", node->style.padding[CSS_BOTTOM]);
       print_number_0("paddingStart", node->style.padding[CSS_START]);
       print_number_0("paddingEnd", node->style.padding[CSS_END]);
     }

     if (four_equal(node->style.border)) {
       print_number_0("borderWidth", node->style.border[CSS_LEFT]);
     } else {
       print_number_0("borderLeftWidth", node->style.border[CSS_LEFT]);
       print_number_0("borderRightWidth", node->style.border[CSS_RIGHT]);
       print_number_0("borderTopWidth", node->style.border[CSS_TOP]);
       print_number_0("borderBottomWidth", node->style.border[CSS_BOTTOM]);
       print_number_0("borderStartWidth", node->style.border[CSS_START]);
       print_number_0("borderEndWidth", node->style.border[CSS_END]);
     }

     print_number_nan("width", node->style.dimensions[CSS_WIDTH]);
     print_number_nan("height", node->style.dimensions[CSS_HEIGHT]);

     if (node->style.position_type == CSS_POSITION_ABSOLUTE) {
       printf("position: 'absolute', ");
     }

     print_number_nan("left", node->style.position[CSS_LEFT]);
     print_number_nan("right", node->style.position[CSS_RIGHT]);
     print_number_nan("top", node->style.position[CSS_TOP]);
     print_number_nan("bottom", node->style.position[CSS_BOTTOM]);
   }

   if (options & CSS_PRINT_CHILDREN && node->children_count > 0) {
     printf("children: [\n");
     for (int i = 0; i < node->children_count; ++i) {
       print_css_node_rec(node->get_child(node->context, i), options, level + 1);
     }
     indent(level);
     printf("]},\n");
   } else {
     printf("},\n");
   }
 }

 void print_css_node(css_node_t *node, css_print_options_t options) {
   print_css_node_rec(node, options, 0);
 }


 static css_position_t leading[4] = {
   /* CSS_FLEX_DIRECTION_COLUMN = */ CSS_TOP,
   /* CSS_FLEX_DIRECTION_COLUMN_REVERSE = */ CSS_BOTTOM,
   /* CSS_FLEX_DIRECTION_ROW = */ CSS_LEFT,
   /* CSS_FLEX_DIRECTION_ROW_REVERSE = */ CSS_RIGHT
 };
 static css_position_t trailing[4] = {
   /* CSS_FLEX_DIRECTION_COLUMN = */ CSS_BOTTOM,
   /* CSS_FLEX_DIRECTION_COLUMN_REVERSE = */ CSS_TOP,
   /* CSS_FLEX_DIRECTION_ROW = */ CSS_RIGHT,
   /* CSS_FLEX_DIRECTION_ROW_REVERSE = */ CSS_LEFT
 };
 static css_position_t pos[4] = {
   /* CSS_FLEX_DIRECTION_COLUMN = */ CSS_TOP,
   /* CSS_FLEX_DIRECTION_COLUMN_REVERSE = */ CSS_BOTTOM,
   /* CSS_FLEX_DIRECTION_ROW = */ CSS_LEFT,
   /* CSS_FLEX_DIRECTION_ROW_REVERSE = */ CSS_RIGHT
 };
 static css_dimension_t dim[4] = {
   /* CSS_FLEX_DIRECTION_COLUMN = */ CSS_HEIGHT,
   /* CSS_FLEX_DIRECTION_COLUMN_REVERSE = */ CSS_HEIGHT,
   /* CSS_FLEX_DIRECTION_ROW = */ CSS_WIDTH,
   /* CSS_FLEX_DIRECTION_ROW_REVERSE = */ CSS_WIDTH
 };

 static bool isRowDirection(css_flex_direction_t flex_direction) {
   return flex_direction == CSS_FLEX_DIRECTION_ROW ||
          flex_direction == CSS_FLEX_DIRECTION_ROW_REVERSE;
 }

 static bool isColumnDirection(css_flex_direction_t flex_direction) {
   return flex_direction == CSS_FLEX_DIRECTION_COLUMN ||
          flex_direction == CSS_FLEX_DIRECTION_COLUMN_REVERSE;
 }

 static float getLeadingMargin(css_node_t *node, css_flex_direction_t axis) {
   if (isRowDirection(axis) && !isUndefined(node->style.margin[CSS_START])) {
     return node->style.margin[CSS_START];
   }

   return node->style.margin[leading[axis]];
 }

 static float getTrailingMargin(css_node_t *node, css_flex_direction_t axis) {
   if (isRowDirection(axis) && !isUndefined(node->style.margin[CSS_END])) {
     return node->style.margin[CSS_END];
   }

   return node->style.margin[trailing[axis]];
 }

 static float getLeadingPadding(css_node_t *node, css_flex_direction_t axis) {
   if (isRowDirection(axis) &&
       !isUndefined(node->style.padding[CSS_START]) &&
       node->style.padding[CSS_START] >= 0) {
     return node->style.padding[CSS_START];
   }

   if (node->style.padding[leading[axis]] >= 0) {
     return node->style.padding[leading[axis]];
   }

   return 0;
 }

 static float getTrailingPadding(css_node_t *node, css_flex_direction_t axis) {
   if (isRowDirection(axis) &&
       !isUndefined(node->style.padding[CSS_END]) &&
       node->style.padding[CSS_END] >= 0) {
     return node->style.padding[CSS_END];
   }

   if (node->style.padding[trailing[axis]] >= 0) {
     return node->style.padding[trailing[axis]];
   }

   return 0;
 }

 static float getLeadingBorder(css_node_t *node, css_flex_direction_t axis) {
   if (isRowDirection(axis) &&
       !isUndefined(node->style.border[CSS_START]) &&
       node->style.border[CSS_START] >= 0) {
     return node->style.border[CSS_START];
   }

   if (node->style.border[leading[axis]] >= 0) {
     return node->style.border[leading[axis]];
   }

   return 0;
 }

 static float getTrailingBorder(css_node_t *node, css_flex_direction_t axis) {
   if (isRowDirection(axis) &&
       !isUndefined(node->style.border[CSS_END]) &&
       node->style.border[CSS_END] >= 0) {
     return node->style.border[CSS_END];
   }

   if (node->style.border[trailing[axis]] >= 0) {
     return node->style.border[trailing[axis]];
   }

   return 0;
 }

 static float getLeadingPaddingAndBorder(css_node_t *node, css_flex_direction_t axis) {
   return getLeadingPadding(node, axis) + getLeadingBorder(node, axis);
 }

 static float getTrailingPaddingAndBorder(css_node_t *node, css_flex_direction_t axis) {
   return getTrailingPadding(node, axis) + getTrailingBorder(node, axis);
 }

 static float getBorderAxis(css_node_t *node, css_flex_direction_t axis) {
   return getLeadingBorder(node, axis) + getTrailingBorder(node, axis);
 }

 static float getMarginAxis(css_node_t *node, css_flex_direction_t axis) {
   return getLeadingMargin(node, axis) + getTrailingMargin(node, axis);
 }

 static float getPaddingAndBorderAxis(css_node_t *node, css_flex_direction_t axis) {
   return getLeadingPaddingAndBorder(node, axis) + getTrailingPaddingAndBorder(node, axis);
 }

 static css_align_t getAlignItem(css_node_t *node, css_node_t *child) {
   if (child->style.align_self != CSS_ALIGN_AUTO) {
     return child->style.align_self;
   }
   return node->style.align_items;
 }

 static css_direction_t resolveDirection(css_node_t *node, css_direction_t parentDirection) {
   css_direction_t direction = node->style.direction;

   if (direction == CSS_DIRECTION_INHERIT) {
     direction = parentDirection > CSS_DIRECTION_INHERIT ? parentDirection : CSS_DIRECTION_LTR;
   }

   return direction;
 }

 static css_flex_direction_t getFlexDirection(css_node_t *node) {
   return node->style.flex_direction;
 }

 static css_flex_direction_t resolveAxis(css_flex_direction_t flex_direction, css_direction_t direction) {
   if (direction == CSS_DIRECTION_RTL) {
     if (flex_direction == CSS_FLEX_DIRECTION_ROW) {
       return CSS_FLEX_DIRECTION_ROW_REVERSE;
     } else if (flex_direction == CSS_FLEX_DIRECTION_ROW_REVERSE) {
       return CSS_FLEX_DIRECTION_ROW;
     }
   }

   return flex_direction;
 }

 static css_flex_direction_t getCrossFlexDirection(css_flex_direction_t flex_direction, css_direction_t direction) {
   if (isColumnDirection(flex_direction)) {
     return resolveAxis(CSS_FLEX_DIRECTION_ROW, direction);
   } else {
     return CSS_FLEX_DIRECTION_COLUMN;
   }
 }

 static float getFlex(css_node_t *node) {
   return node->style.flex;
 }

 static bool isFlex(css_node_t *node) {
   return (
     node->style.position_type == CSS_POSITION_RELATIVE &&
     getFlex(node) > 0
   );
 }

 static bool isFlexWrap(css_node_t *node) {
   return node->style.flex_wrap == CSS_WRAP;
 }

 static float getDimWithMargin(css_node_t *node, css_flex_direction_t axis) {
   return node->layout.dimensions[dim[axis]] +
     getLeadingMargin(node, axis) +
     getTrailingMargin(node, axis);
 }

 static bool isStyleDimDefined(css_node_t *node, css_flex_direction_t axis) {
   float value = node->style.dimensions[dim[axis]];
   return !isUndefined(value) && value >= 0.0;
 }

 static bool isLayoutDimDefined(css_node_t *node, css_flex_direction_t axis) {
   float value = node->layout.dimensions[dim[axis]];
   return !isUndefined(value) && value >= 0.0;
 }

 static bool isPosDefined(css_node_t *node, css_position_t position) {
   return !isUndefined(node->style.position[position]);
 }

 static bool isMeasureDefined(css_node_t *node) {
   return node->measure;
 }

 static float getPosition(css_node_t *node, css_position_t position) {
   float result = node->style.position[position];
   if (!isUndefined(result)) {
     return result;
   }
   return 0;
 }

 static float boundAxis(css_node_t *node, css_flex_direction_t axis, float value) {
   float min = CSS_UNDEFINED;
   float max = CSS_UNDEFINED;

   if (isColumnDirection(axis)) {
     min = node->style.minDimensions[CSS_HEIGHT];
     max = node->style.maxDimensions[CSS_HEIGHT];
   } else if (isRowDirection(axis)) {
     min = node->style.minDimensions[CSS_WIDTH];
     max = node->style.maxDimensions[CSS_WIDTH];
   }

   float boundValue = value;

   if (!isUndefined(max) && max >= 0.0 && boundValue > max) {
     boundValue = max;
   }
   if (!isUndefined(min) && min >= 0.0 && boundValue < min) {
     boundValue = min;
   }

   return boundValue;
 }

 // When the user specifically sets a value for width or height
 static void setDimensionFromStyle(css_node_t *node, css_flex_direction_t axis) {
   // The parent already computed us a width or height. We just skip it
   if (isLayoutDimDefined(node, axis)) {
     return;
   }
   // We only run if there's a width or height defined
   if (!isStyleDimDefined(node, axis)) {
     return;
   }

   // The dimensions can never be smaller than the padding and border
   node->layout.dimensions[dim[axis]] = fmaxf(
     boundAxis(node, axis, node->style.dimensions[dim[axis]]),
     getPaddingAndBorderAxis(node, axis)
   );
 }

 static void setTrailingPosition(css_node_t *node, css_node_t *child, css_flex_direction_t axis) {
     child->layout.position[trailing[axis]] = node->layout.dimensions[dim[axis]] -
       child->layout.dimensions[dim[axis]] - child->layout.position[pos[axis]];
   }

 // If both left and right are defined, then use left. Otherwise return
 // +left or -right depending on which is defined.
 static float getRelativePosition(css_node_t *node, css_flex_direction_t axis) {
   float lead = node->style.position[leading[axis]];
   if (!isUndefined(lead)) {
     return lead;
   }
   return -getPosition(node, trailing[axis]);
 }

 static void layoutNodeImpl(css_node_t *node, float parentMaxWidth, float parentMaxHeight, css_direction_t parentDirection) {
   /** START_GENERATED **/
   css_direction_t direction = resolveDirection(node, parentDirection);
   css_flex_direction_t mainAxis = resolveAxis(getFlexDirection(node), direction);
   css_flex_direction_t crossAxis = getCrossFlexDirection(mainAxis, direction);
   css_flex_direction_t resolvedRowAxis = resolveAxis(CSS_FLEX_DIRECTION_ROW, direction);

   // Handle width and height style attributes
   setDimensionFromStyle(node, mainAxis);
   setDimensionFromStyle(node, crossAxis);

   // Set the resolved resolution in the node's layout
   node->layout.direction = direction;

   // The position is set by the parent, but we need to complete it with a
   // delta composed of the margin and left/top/right/bottom
   node->layout.position[leading[mainAxis]] += getLeadingMargin(node, mainAxis) +
     getRelativePosition(node, mainAxis);
   node->layout.position[trailing[mainAxis]] += getTrailingMargin(node, mainAxis) +
     getRelativePosition(node, mainAxis);
   node->layout.position[leading[crossAxis]] += getLeadingMargin(node, crossAxis) +
     getRelativePosition(node, crossAxis);
   node->layout.position[trailing[crossAxis]] += getTrailingMargin(node, crossAxis) +
     getRelativePosition(node, crossAxis);

   // Inline immutable values from the target node to avoid excessive method
   // invocations during the layout calculation.
   int childCount = node->children_count;
   float paddingAndBorderAxisResolvedRow = getPaddingAndBorderAxis(node, resolvedRowAxis);
   float paddingAndBorderAxisColumn = getPaddingAndBorderAxis(node, CSS_FLEX_DIRECTION_COLUMN);

   if (isMeasureDefined(node)) {
     bool isResolvedRowDimDefined = isLayoutDimDefined(node, resolvedRowAxis);

     float width = CSS_UNDEFINED;
     css_measure_mode_t widthMode = CSS_MEASURE_MODE_UNDEFINED;
     if (isStyleDimDefined(node, resolvedRowAxis)) {
       width = node->style.dimensions[CSS_WIDTH];
       widthMode = CSS_MEASURE_MODE_EXACTLY;
     } else if (isResolvedRowDimDefined) {
       width = node->layout.dimensions[dim[resolvedRowAxis]];
       widthMode = CSS_MEASURE_MODE_EXACTLY;
     } else {
       width = parentMaxWidth -
         getMarginAxis(node, resolvedRowAxis);
       widthMode = CSS_MEASURE_MODE_AT_MOST;
     }
     width -= paddingAndBorderAxisResolvedRow;
     if (isUndefined(width)) {
       widthMode = CSS_MEASURE_MODE_UNDEFINED;
     }

     float height = CSS_UNDEFINED;
     css_measure_mode_t heightMode = CSS_MEASURE_MODE_UNDEFINED;
     if (isStyleDimDefined(node, CSS_FLEX_DIRECTION_COLUMN)) {
       height = node->style.dimensions[CSS_HEIGHT];
       heightMode = CSS_MEASURE_MODE_EXACTLY;
     } else if (isLayoutDimDefined(node, CSS_FLEX_DIRECTION_COLUMN)) {
       height = node->layout.dimensions[dim[CSS_FLEX_DIRECTION_COLUMN]];
       heightMode = CSS_MEASURE_MODE_EXACTLY;
     } else {
       height = parentMaxHeight -
         getMarginAxis(node, resolvedRowAxis);
       heightMode = CSS_MEASURE_MODE_AT_MOST;
     }
     height -= getPaddingAndBorderAxis(node, CSS_FLEX_DIRECTION_COLUMN);
     if (isUndefined(height)) {
       heightMode = CSS_MEASURE_MODE_UNDEFINED;
     }

     // We only need to give a dimension for the text if we haven't got any
     // for it computed yet. It can either be from the style attribute or because
     // the element is flexible.
     bool isRowUndefined = !isStyleDimDefined(node, resolvedRowAxis) && !isResolvedRowDimDefined;
     bool isColumnUndefined = !isStyleDimDefined(node, CSS_FLEX_DIRECTION_COLUMN) &&
       isUndefined(node->layout.dimensions[dim[CSS_FLEX_DIRECTION_COLUMN]]);

     // Let's not measure the text if we already know both dimensions
     if (isRowUndefined || isColumnUndefined) {
       css_dim_t measureDim = node->measure(
         node->context,

         width,
         widthMode,
         height,
         heightMode
       );
       if (isRowUndefined) {
         node->layout.dimensions[CSS_WIDTH] = measureDim.dimensions[CSS_WIDTH] +
           paddingAndBorderAxisResolvedRow;
       }
       if (isColumnUndefined) {
         node->layout.dimensions[CSS_HEIGHT] = measureDim.dimensions[CSS_HEIGHT] +
           paddingAndBorderAxisColumn;
       }
     }
     if (childCount == 0) {
       return;
     }
   }

   bool isNodeFlexWrap = isFlexWrap(node);

   css_justify_t justifyContent = node->style.justify_content;

   float leadingPaddingAndBorderMain = getLeadingPaddingAndBorder(node, mainAxis);
   float leadingPaddingAndBorderCross = getLeadingPaddingAndBorder(node, crossAxis);
   float paddingAndBorderAxisMain = getPaddingAndBorderAxis(node, mainAxis);
   float paddingAndBorderAxisCross = getPaddingAndBorderAxis(node, crossAxis);

   bool isMainDimDefined = isLayoutDimDefined(node, mainAxis);
   bool isCrossDimDefined = isLayoutDimDefined(node, crossAxis);
   bool isMainRowDirection = isRowDirection(mainAxis);

   int i;
   int ii;
   css_node_t* child;
   css_flex_direction_t axis;

   css_node_t* firstAbsoluteChild = NULL;
   css_node_t* currentAbsoluteChild = NULL;

   float definedMainDim = CSS_UNDEFINED;
   if (isMainDimDefined) {
     definedMainDim = node->layout.dimensions[dim[mainAxis]] - paddingAndBorderAxisMain;
   }

   // We want to execute the next two loops one per line with flex-wrap
   int startLine = 0;
   int endLine = 0;
   // int nextOffset = 0;
   int alreadyComputedNextLayout = 0;
   // We aggregate the total dimensions of the container in those two variables
   float linesCrossDim = 0;
   float linesMainDim = 0;
   int linesCount = 0;
   while (endLine < childCount) {
     // <Loop A> Layout non flexible children and count children by type

     // mainContentDim is accumulation of the dimensions and margin of all the
     // non flexible children. This will be used in order to either set the
     // dimensions of the node if none already exist, or to compute the
     // remaining space left for the flexible children.
     float mainContentDim = 0;

     // There are three kind of children, non flexible, flexible and absolute.
     // We need to know how many there are in order to distribute the space.
     int flexibleChildrenCount = 0;
     float totalFlexible = 0;
     int nonFlexibleChildrenCount = 0;

     // Use the line loop to position children in the main axis for as long
     // as they are using a simple stacking behaviour. Children that are
     // immediately stacked in the initial loop will not be touched again
     // in <Loop C>.
     bool isSimpleStackMain =
         (isMainDimDefined && justifyContent == CSS_JUSTIFY_FLEX_START) ||
         (!isMainDimDefined && justifyContent != CSS_JUSTIFY_CENTER);
     int firstComplexMain = (isSimpleStackMain ? childCount : startLine);

     // Use the initial line loop to position children in the cross axis for
     // as long as they are relatively positioned with alignment STRETCH or
     // FLEX_START. Children that are immediately stacked in the initial loop
     // will not be touched again in <Loop D>.
     bool isSimpleStackCross = true;
     int firstComplexCross = childCount;

     css_node_t* firstFlexChild = NULL;
     css_node_t* currentFlexChild = NULL;

     float mainDim = leadingPaddingAndBorderMain;
     float crossDim = 0;

     float maxWidth = CSS_UNDEFINED;
     float maxHeight = CSS_UNDEFINED;
     for (i = startLine; i < childCount; ++i) {
       child = node->get_child(node->context, i);
       child->line_index = linesCount;

       child->next_absolute_child = NULL;
       child->next_flex_child = NULL;

       css_align_t alignItem = getAlignItem(node, child);

       // Pre-fill cross axis dimensions when the child is using stretch before
       // we call the recursive layout pass
       if (alignItem == CSS_ALIGN_STRETCH &&
           child->style.position_type == CSS_POSITION_RELATIVE &&
           isCrossDimDefined &&
           !isStyleDimDefined(child, crossAxis)) {
         child->layout.dimensions[dim[crossAxis]] = fmaxf(
           boundAxis(child, crossAxis, node->layout.dimensions[dim[crossAxis]] -
             paddingAndBorderAxisCross - getMarginAxis(child, crossAxis)),
           // You never want to go smaller than padding
           getPaddingAndBorderAxis(child, crossAxis)
         );
       } else if (child->style.position_type == CSS_POSITION_ABSOLUTE) {
         // Store a private linked list of absolutely positioned children
         // so that we can efficiently traverse them later.
         if (firstAbsoluteChild == NULL) {
           firstAbsoluteChild = child;
         }
         if (currentAbsoluteChild != NULL) {
           currentAbsoluteChild->next_absolute_child = child;
         }
         currentAbsoluteChild = child;

         // Pre-fill dimensions when using absolute position and both offsets for the axis are defined (either both
         // left and right or top and bottom).
         for (ii = 0; ii < 2; ii++) {
           axis = (ii != 0) ? CSS_FLEX_DIRECTION_ROW : CSS_FLEX_DIRECTION_COLUMN;
           if (isLayoutDimDefined(node, axis) &&
               !isStyleDimDefined(child, axis) &&
               isPosDefined(child, leading[axis]) &&
               isPosDefined(child, trailing[axis])) {
             child->layout.dimensions[dim[axis]] = fmaxf(
               boundAxis(child, axis, node->layout.dimensions[dim[axis]] -
                 getPaddingAndBorderAxis(node, axis) -
                 getMarginAxis(child, axis) -
                 getPosition(child, leading[axis]) -
                 getPosition(child, trailing[axis])),
               // You never want to go smaller than padding
               getPaddingAndBorderAxis(child, axis)
             );
           }
         }
       }

       float nextContentDim = 0;

       // It only makes sense to consider a child flexible if we have a computed
       // dimension for the node->
       if (isMainDimDefined && isFlex(child)) {
         flexibleChildrenCount++;
         totalFlexible += child->style.flex;

         // Store a private linked list of flexible children so that we can
         // efficiently traverse them later.
         if (firstFlexChild == NULL) {
           firstFlexChild = child;
         }
         if (currentFlexChild != NULL) {
           currentFlexChild->next_flex_child = child;
         }
         currentFlexChild = child;

         // Even if we don't know its exact size yet, we already know the padding,
         // border and margin. We'll use this partial information, which represents
         // the smallest possible size for the child, to compute the remaining
         // available space.
         nextContentDim = getPaddingAndBorderAxis(child, mainAxis) +
           getMarginAxis(child, mainAxis);

       } else {
         maxWidth = CSS_UNDEFINED;
         maxHeight = CSS_UNDEFINED;

         if (!isMainRowDirection) {
           if (isLayoutDimDefined(node, resolvedRowAxis)) {
             maxWidth = node->layout.dimensions[dim[resolvedRowAxis]] -
               paddingAndBorderAxisResolvedRow;
           } else {
             maxWidth = parentMaxWidth -
               getMarginAxis(node, resolvedRowAxis) -
               paddingAndBorderAxisResolvedRow;
           }
         } else {
           if (isLayoutDimDefined(node, CSS_FLEX_DIRECTION_COLUMN)) {
             maxHeight = node->layout.dimensions[dim[CSS_FLEX_DIRECTION_COLUMN]] -
                 paddingAndBorderAxisColumn;
           } else {
             maxHeight = parentMaxHeight -
               getMarginAxis(node, CSS_FLEX_DIRECTION_COLUMN) -
               paddingAndBorderAxisColumn;
           }
         }

         // This is the main recursive call. We layout non flexible children.
         if (alreadyComputedNextLayout == 0) {
           layoutNode(child, maxWidth, maxHeight, direction);
         }

         // Absolute positioned elements do not take part of the layout, so we
         // don't use them to compute mainContentDim
         if (child->style.position_type == CSS_POSITION_RELATIVE) {
           nonFlexibleChildrenCount++;
           // At this point we know the final size and margin of the element.
           nextContentDim = getDimWithMargin(child, mainAxis);
         }
       }

       // The element we are about to add would make us go to the next line
       if (isNodeFlexWrap &&
           isMainDimDefined &&
           mainContentDim + nextContentDim > definedMainDim &&
           // If there's only one element, then it's bigger than the content
           // and needs its own line
           i != startLine) {
         nonFlexibleChildrenCount--;
         alreadyComputedNextLayout = 1;
         break;
       }

       // Disable simple stacking in the main axis for the current line as
       // we found a non-trivial child-> The remaining children will be laid out
       // in <Loop C>.
       if (isSimpleStackMain &&
           (child->style.position_type != CSS_POSITION_RELATIVE || isFlex(child))) {
         isSimpleStackMain = false;
         firstComplexMain = i;
       }

       // Disable simple stacking in the cross axis for the current line as
       // we found a non-trivial child-> The remaining children will be laid out
       // in <Loop D>.
       if (isSimpleStackCross &&
           (child->style.position_type != CSS_POSITION_RELATIVE ||
               (alignItem != CSS_ALIGN_STRETCH && alignItem != CSS_ALIGN_FLEX_START) ||
               (alignItem == CSS_ALIGN_STRETCH && !isCrossDimDefined))) {
         isSimpleStackCross = false;
         firstComplexCross = i;
       }

       if (isSimpleStackMain) {
         child->layout.position[pos[mainAxis]] += mainDim;
         if (isMainDimDefined) {
           setTrailingPosition(node, child, mainAxis);
         }

         mainDim += getDimWithMargin(child, mainAxis);
         crossDim = fmaxf(crossDim, boundAxis(child, crossAxis, getDimWithMargin(child, crossAxis)));
       }

       if (isSimpleStackCross) {
         child->layout.position[pos[crossAxis]] += linesCrossDim + leadingPaddingAndBorderCross;
         if (isCrossDimDefined) {
           setTrailingPosition(node, child, crossAxis);
         }
       }

       alreadyComputedNextLayout = 0;
       mainContentDim += nextContentDim;
       endLine = i + 1;
     }

     // <Loop B> Layout flexible children and allocate empty space

     // In order to position the elements in the main axis, we have two
     // controls. The space between the beginning and the first element
     // and the space between each two elements.
     float leadingMainDim = 0;
     float betweenMainDim = 0;

     // The remaining available space that needs to be allocated
     float remainingMainDim = 0;
     if (isMainDimDefined) {
       remainingMainDim = definedMainDim - mainContentDim;
     } else {
       remainingMainDim = fmaxf(mainContentDim, 0) - mainContentDim;
     }

     // If there are flexible children in the mix, they are going to fill the
     // remaining space
     if (flexibleChildrenCount != 0) {
       float flexibleMainDim = remainingMainDim / totalFlexible;
       float baseMainDim;
       float boundMainDim;

       // If the flex share of remaining space doesn't meet min/max bounds,
       // remove this child from flex calculations.
       currentFlexChild = firstFlexChild;
       while (currentFlexChild != NULL) {
         baseMainDim = flexibleMainDim * currentFlexChild->style.flex +
             getPaddingAndBorderAxis(currentFlexChild, mainAxis);
         boundMainDim = boundAxis(currentFlexChild, mainAxis, baseMainDim);

         if (baseMainDim != boundMainDim) {
           remainingMainDim -= boundMainDim;
           totalFlexible -= currentFlexChild->style.flex;
         }

         currentFlexChild = currentFlexChild->next_flex_child;
       }
       flexibleMainDim = remainingMainDim / totalFlexible;

       // The non flexible children can overflow the container, in this case
       // we should just assume that there is no space available.
       if (flexibleMainDim < 0) {
         flexibleMainDim = 0;
       }

       currentFlexChild = firstFlexChild;
       while (currentFlexChild != NULL) {
         // At this point we know the final size of the element in the main
         // dimension
         currentFlexChild->layout.dimensions[dim[mainAxis]] = boundAxis(currentFlexChild, mainAxis,
           flexibleMainDim * currentFlexChild->style.flex +
               getPaddingAndBorderAxis(currentFlexChild, mainAxis)
         );

         maxWidth = CSS_UNDEFINED;
         if (isLayoutDimDefined(node, resolvedRowAxis)) {
           maxWidth = node->layout.dimensions[dim[resolvedRowAxis]] -
             paddingAndBorderAxisResolvedRow;
         } else if (!isMainRowDirection) {
           maxWidth = parentMaxWidth -
             getMarginAxis(node, resolvedRowAxis) -
             paddingAndBorderAxisResolvedRow;
         }
         maxHeight = CSS_UNDEFINED;
         if (isLayoutDimDefined(node, CSS_FLEX_DIRECTION_COLUMN)) {
           maxHeight = node->layout.dimensions[dim[CSS_FLEX_DIRECTION_COLUMN]] -
             paddingAndBorderAxisColumn;
         } else if (isMainRowDirection) {
           maxHeight = parentMaxHeight -
             getMarginAxis(node, CSS_FLEX_DIRECTION_COLUMN) -
             paddingAndBorderAxisColumn;
         }

         // And we recursively call the layout algorithm for this child
         layoutNode(currentFlexChild, maxWidth, maxHeight, direction);

         child = currentFlexChild;
         currentFlexChild = currentFlexChild->next_flex_child;
         child->next_flex_child = NULL;
       }

     // We use justifyContent to figure out how to allocate the remaining
     // space available
     } else if (justifyContent != CSS_JUSTIFY_FLEX_START) {
       if (justifyContent == CSS_JUSTIFY_CENTER) {
         leadingMainDim = remainingMainDim / 2;
       } else if (justifyContent == CSS_JUSTIFY_FLEX_END) {
         leadingMainDim = remainingMainDim;
       } else if (justifyContent == CSS_JUSTIFY_SPACE_BETWEEN) {
         remainingMainDim = fmaxf(remainingMainDim, 0);
         if (flexibleChildrenCount + nonFlexibleChildrenCount - 1 != 0) {
           betweenMainDim = remainingMainDim /
             (flexibleChildrenCount + nonFlexibleChildrenCount - 1);
         } else {
           betweenMainDim = 0;
         }
       } else if (justifyContent == CSS_JUSTIFY_SPACE_AROUND) {
         // Space on the edges is half of the space between elements
         betweenMainDim = remainingMainDim /
           (flexibleChildrenCount + nonFlexibleChildrenCount);
         leadingMainDim = betweenMainDim / 2;
       }
     }

     // <Loop C> Position elements in the main axis and compute dimensions

     // At this point, all the children have their dimensions set. We need to
     // find their position. In order to do that, we accumulate data in
     // variables that are also useful to compute the total dimensions of the
     // container!
     mainDim += leadingMainDim;

     for (i = firstComplexMain; i < endLine; ++i) {
       child = node->get_child(node->context, i);

       if (child->style.position_type == CSS_POSITION_ABSOLUTE &&
           isPosDefined(child, leading[mainAxis])) {
         // In case the child is position absolute and has left/top being
         // defined, we override the position to whatever the user said
         // (and margin/border).
         child->layout.position[pos[mainAxis]] = getPosition(child, leading[mainAxis]) +
           getLeadingBorder(node, mainAxis) +
           getLeadingMargin(child, mainAxis);
       } else {
         // If the child is position absolute (without top/left) or relative,
         // we put it at the current accumulated offset.
         child->layout.position[pos[mainAxis]] += mainDim;

         // Define the trailing position accordingly.
         if (isMainDimDefined) {
           setTrailingPosition(node, child, mainAxis);
         }

         // Now that we placed the element, we need to update the variables
         // We only need to do that for relative elements. Absolute elements
         // do not take part in that phase.
         if (child->style.position_type == CSS_POSITION_RELATIVE) {
           // The main dimension is the sum of all the elements dimension plus
           // the spacing.
           mainDim += betweenMainDim + getDimWithMargin(child, mainAxis);
           // The cross dimension is the max of the elements dimension since there
           // can only be one element in that cross dimension.
           crossDim = fmaxf(crossDim, boundAxis(child, crossAxis, getDimWithMargin(child, crossAxis)));
         }
       }
     }

     float containerCrossAxis = node->layout.dimensions[dim[crossAxis]];
     if (!isCrossDimDefined) {
       containerCrossAxis = fmaxf(
         // For the cross dim, we add both sides at the end because the value
         // is aggregate via a max function. Intermediate negative values
         // can mess this computation otherwise
         boundAxis(node, crossAxis, crossDim + paddingAndBorderAxisCross),
         paddingAndBorderAxisCross
       );
     }

     // <Loop D> Position elements in the cross axis
     for (i = firstComplexCross; i < endLine; ++i) {
       child = node->get_child(node->context, i);

       if (child->style.position_type == CSS_POSITION_ABSOLUTE &&
           isPosDefined(child, leading[crossAxis])) {
         // In case the child is absolutely positionned and has a
         // top/left/bottom/right being set, we override all the previously
         // computed positions to set it correctly.
         child->layout.position[pos[crossAxis]] = getPosition(child, leading[crossAxis]) +
           getLeadingBorder(node, crossAxis) +
           getLeadingMargin(child, crossAxis);

       } else {
         float leadingCrossDim = leadingPaddingAndBorderCross;

         // For a relative children, we're either using alignItems (parent) or
         // alignSelf (child) in order to determine the position in the cross axis
         if (child->style.position_type == CSS_POSITION_RELATIVE) {
           /*eslint-disable */
           // This variable is intentionally re-defined as the code is transpiled to a block scope language
           css_align_t alignItem = getAlignItem(node, child);
           /*eslint-enable */
           if (alignItem == CSS_ALIGN_STRETCH) {
             // You can only stretch if the dimension has not already been defined
             // previously.
             if (!isStyleDimDefined(child, crossAxis)) {
               float dimCrossAxis = child->layout.dimensions[dim[crossAxis]];
               child->layout.dimensions[dim[crossAxis]] = fmaxf(
                 boundAxis(child, crossAxis, containerCrossAxis -
                   paddingAndBorderAxisCross - getMarginAxis(child, crossAxis)),
                 // You never want to go smaller than padding
                 getPaddingAndBorderAxis(child, crossAxis)
               );

               // If the size has changed, and this child has children we need to re-layout this child
               if (dimCrossAxis != child->layout.dimensions[dim[crossAxis]] && child->children_count > 0) {
                 // Reset child margins before re-layout as they are added back in layoutNode and would be doubled
                 child->layout.position[leading[mainAxis]] -= getLeadingMargin(child, mainAxis) +
                   getRelativePosition(child, mainAxis);
                 child->layout.position[trailing[mainAxis]] -= getTrailingMargin(child, mainAxis) +
                   getRelativePosition(child, mainAxis);
                 child->layout.position[leading[crossAxis]] -= getLeadingMargin(child, crossAxis) +
                   getRelativePosition(child, crossAxis);
                 child->layout.position[trailing[crossAxis]] -= getTrailingMargin(child, crossAxis) +
                   getRelativePosition(child, crossAxis);

                 layoutNode(child, maxWidth, maxHeight, direction);
               }
             }
           } else if (alignItem != CSS_ALIGN_FLEX_START) {
             // The remaining space between the parent dimensions+padding and child
             // dimensions+margin.
             float remainingCrossDim = containerCrossAxis -
               paddingAndBorderAxisCross - getDimWithMargin(child, crossAxis);

             if (alignItem == CSS_ALIGN_CENTER) {
               leadingCrossDim += remainingCrossDim / 2;
             } else { // CSS_ALIGN_FLEX_END
               leadingCrossDim += remainingCrossDim;
             }
           }
         }

         // And we apply the position
         child->layout.position[pos[crossAxis]] += linesCrossDim + leadingCrossDim;

         // Define the trailing position accordingly.
         if (isCrossDimDefined) {
           setTrailingPosition(node, child, crossAxis);
         }
       }
     }

     linesCrossDim += crossDim;
     linesMainDim = fmaxf(linesMainDim, mainDim);
     linesCount += 1;
     startLine = endLine;
   }

   // <Loop E>
   //
   // Note(prenaux): More than one line, we need to layout the crossAxis
   // according to alignContent.
   //
   // Note that we could probably remove <Loop D> and handle the one line case
   // here too, but for the moment this is safer since it won't interfere with
   // previously working code.
   //
   // See specs:
   // http://www.w3.org/TR/2012/CR-css3-flexbox-20120918/#layout-algorithm
   // section 9.4
   //
   if (linesCount > 1 && isCrossDimDefined) {
     float nodeCrossAxisInnerSize = node->layout.dimensions[dim[crossAxis]] -
         paddingAndBorderAxisCross;
     float remainingAlignContentDim = nodeCrossAxisInnerSize - linesCrossDim;

     float crossDimLead = 0;
     float currentLead = leadingPaddingAndBorderCross;

     css_align_t alignContent = node->style.align_content;
     if (alignContent == CSS_ALIGN_FLEX_END) {
       currentLead += remainingAlignContentDim;
     } else if (alignContent == CSS_ALIGN_CENTER) {
       currentLead += remainingAlignContentDim / 2;
     } else if (alignContent == CSS_ALIGN_STRETCH) {
       if (nodeCrossAxisInnerSize > linesCrossDim) {
         crossDimLead = (remainingAlignContentDim / linesCount);
       }
     }

     int endIndex = 0;
     for (i = 0; i < linesCount; ++i) {
       int startIndex = endIndex;

       // compute the line's height and find the endIndex
       float lineHeight = 0;
       for (ii = startIndex; ii < childCount; ++ii) {
         child = node->get_child(node->context, ii);
         if (child->style.position_type != CSS_POSITION_RELATIVE) {
           continue;
         }
         if (child->line_index != i) {
           break;
         }
         if (isLayoutDimDefined(child, crossAxis)) {
           lineHeight = fmaxf(
             lineHeight,
             child->layout.dimensions[dim[crossAxis]] + getMarginAxis(child, crossAxis)
           );
         }
       }
       endIndex = ii;
       lineHeight += crossDimLead;

       for (ii = startIndex; ii < endIndex; ++ii) {
         child = node->get_child(node->context, ii);
         if (child->style.position_type != CSS_POSITION_RELATIVE) {
           continue;
         }

         css_align_t alignContentAlignItem = getAlignItem(node, child);
         if (alignContentAlignItem == CSS_ALIGN_FLEX_START) {
           child->layout.position[pos[crossAxis]] = currentLead + getLeadingMargin(child, crossAxis);
         } else if (alignContentAlignItem == CSS_ALIGN_FLEX_END) {
           child->layout.position[pos[crossAxis]] = currentLead + lineHeight - getTrailingMargin(child, crossAxis) - child->layout.dimensions[dim[crossAxis]];
         } else if (alignContentAlignItem == CSS_ALIGN_CENTER) {
           float childHeight = child->layout.dimensions[dim[crossAxis]];
           child->layout.position[pos[crossAxis]] = currentLead + (lineHeight - childHeight) / 2;
         } else if (alignContentAlignItem == CSS_ALIGN_STRETCH) {
           child->layout.position[pos[crossAxis]] = currentLead + getLeadingMargin(child, crossAxis);
           // TODO(prenaux): Correctly set the height of items with undefined
           //                (auto) crossAxis dimension.
         }
       }

       currentLead += lineHeight;
     }
   }

   bool needsMainTrailingPos = false;
   bool needsCrossTrailingPos = false;

   // If the user didn't specify a width or height, and it has not been set
   // by the container, then we set it via the children.
   if (!isMainDimDefined) {
     node->layout.dimensions[dim[mainAxis]] = fmaxf(
       // We're missing the last padding at this point to get the final
       // dimension
       boundAxis(node, mainAxis, linesMainDim + getTrailingPaddingAndBorder(node, mainAxis)),
       // We can never assign a width smaller than the padding and borders
       paddingAndBorderAxisMain
     );

     if (mainAxis == CSS_FLEX_DIRECTION_ROW_REVERSE ||
         mainAxis == CSS_FLEX_DIRECTION_COLUMN_REVERSE) {
       needsMainTrailingPos = true;
     }
   }

   if (!isCrossDimDefined) {
     node->layout.dimensions[dim[crossAxis]] = fmaxf(
       // For the cross dim, we add both sides at the end because the value
       // is aggregate via a max function. Intermediate negative values
       // can mess this computation otherwise
       boundAxis(node, crossAxis, linesCrossDim + paddingAndBorderAxisCross),
       paddingAndBorderAxisCross
     );

     if (crossAxis == CSS_FLEX_DIRECTION_ROW_REVERSE ||
         crossAxis == CSS_FLEX_DIRECTION_COLUMN_REVERSE) {
       needsCrossTrailingPos = true;
     }
   }

   // <Loop F> Set trailing position if necessary
   if (needsMainTrailingPos || needsCrossTrailingPos) {
     for (i = 0; i < childCount; ++i) {
       child = node->get_child(node->context, i);

       if (needsMainTrailingPos) {
         setTrailingPosition(node, child, mainAxis);
       }

       if (needsCrossTrailingPos) {
         setTrailingPosition(node, child, crossAxis);
       }
     }
   }

   // <Loop G> Calculate dimensions for absolutely positioned elements
   currentAbsoluteChild = firstAbsoluteChild;
   while (currentAbsoluteChild != NULL) {
     // Pre-fill dimensions when using absolute position and both offsets for
     // the axis are defined (either both left and right or top and bottom).
     for (ii = 0; ii < 2; ii++) {
       axis = (ii != 0) ? CSS_FLEX_DIRECTION_ROW : CSS_FLEX_DIRECTION_COLUMN;

       if (isLayoutDimDefined(node, axis) &&
           !isStyleDimDefined(currentAbsoluteChild, axis) &&
           isPosDefined(currentAbsoluteChild, leading[axis]) &&
           isPosDefined(currentAbsoluteChild, trailing[axis])) {
         currentAbsoluteChild->layout.dimensions[dim[axis]] = fmaxf(
           boundAxis(currentAbsoluteChild, axis, node->layout.dimensions[dim[axis]] -
             getBorderAxis(node, axis) -
             getMarginAxis(currentAbsoluteChild, axis) -
             getPosition(currentAbsoluteChild, leading[axis]) -
             getPosition(currentAbsoluteChild, trailing[axis])
           ),
           // You never want to go smaller than padding
           getPaddingAndBorderAxis(currentAbsoluteChild, axis)
         );
       }

       if (isPosDefined(currentAbsoluteChild, trailing[axis]) &&
           !isPosDefined(currentAbsoluteChild, leading[axis])) {
         currentAbsoluteChild->layout.position[leading[axis]] =
           node->layout.dimensions[dim[axis]] -
           currentAbsoluteChild->layout.dimensions[dim[axis]] -
           getPosition(currentAbsoluteChild, trailing[axis]);
       }
     }

     child = currentAbsoluteChild;
     currentAbsoluteChild = currentAbsoluteChild->next_absolute_child;
     child->next_absolute_child = NULL;
   }
   /** END_GENERATED **/
 }

 void layoutNode(css_node_t *node, float parentMaxWidth, float parentMaxHeight, css_direction_t parentDirection) {
   css_layout_t *layout = &node->layout;
   css_direction_t direction = node->style.direction;
   layout->should_update = true;

   bool skipLayout =
     !node->is_dirty(node->context) &&
     eq(layout->last_requested_dimensions[CSS_WIDTH], layout->dimensions[CSS_WIDTH]) &&
     eq(layout->last_requested_dimensions[CSS_HEIGHT], layout->dimensions[CSS_HEIGHT]) &&
     eq(layout->last_parent_max_width, parentMaxWidth) &&
     eq(layout->last_parent_max_height, parentMaxHeight) &&
     eq(layout->last_direction, direction);

   if (skipLayout) {
     layout->dimensions[CSS_WIDTH] = layout->last_dimensions[CSS_WIDTH];
     layout->dimensions[CSS_HEIGHT] = layout->last_dimensions[CSS_HEIGHT];
     layout->position[CSS_TOP] = layout->last_position[CSS_TOP];
     layout->position[CSS_LEFT] = layout->last_position[CSS_LEFT];
   } else {
     layout->last_requested_dimensions[CSS_WIDTH] = layout->dimensions[CSS_WIDTH];
     layout->last_requested_dimensions[CSS_HEIGHT] = layout->dimensions[CSS_HEIGHT];
     layout->last_parent_max_width = parentMaxWidth;
     layout->last_parent_max_height = parentMaxHeight;
     layout->last_direction = direction;

     for (int i = 0, childCount = node->children_count; i < childCount; i++) {
       resetNodeLayout(node->get_child(node->context, i));
     }

     layoutNodeImpl(node, parentMaxWidth, parentMaxHeight, parentDirection);

     layout->last_dimensions[CSS_WIDTH] = layout->dimensions[CSS_WIDTH];
     layout->last_dimensions[CSS_HEIGHT] = layout->dimensions[CSS_HEIGHT];
     layout->last_position[CSS_TOP] = layout->position[CSS_TOP];
     layout->last_position[CSS_LEFT] = layout->position[CSS_LEFT];
   }
 }

 void resetNodeLayout(css_node_t *node) {
   node->layout.dimensions[CSS_WIDTH] = CSS_UNDEFINED;
   node->layout.dimensions[CSS_HEIGHT] = CSS_UNDEFINED;
   node->layout.position[CSS_LEFT] = 0;
   node->layout.position[CSS_TOP] = 0;
 }