#include "ccv_nnc.h"

#include "ccv_nnc_easy.h"

#include "ccv_nnc_internal.h"

#include "ccv_internal.h"

#include "_ccv_nnc_micro.h"

#include "3rdparty/khash/khash.h"

#define MICRO_ID_TO_INT(x) (((x).id << 8) | ((x).d))

KHASH_MAP_INIT_INT(ccv_nnc_axis_id_group, int)

static int _ccv_nnc_same_index_term(const ccv_nnc_micro_loop_index_term_t a_index, const ccv_nnc_micro_loop_index_term_t b_index, const int* const groups, khash_t(ccv_nnc_axis_id_group)* const axis_id_groups)

{

  if (a_index.type != b_index.type)

    return 0;

  const int type = a_index.type;

  switch (type)

  {

    case CCV_NNC_MICRO_LOOP_INDEX_TYPE_VAL:

      return a_index.immediate_value == b_index.immediate_value;

    case CCV_NNC_MICRO_LOOP_INDEX_TYPE_ID:

      if (a_index.id.type != b_index.id.type)

        return 0;

      // Check within the axis_id_groups to see if there is a match, if there is no match, we can proceed (to use the group table again to check).

      if (axis_id_groups && 
a_index.id.type == CCV_NNC_MICRO_AXIS_SIZE_ID827
)

      {

        ccv_nnc_micro_id_t a_id = a_index.id;

        while (groups && groups[a_id.id] != a_id.id)

          a_id.id = groups[a_id.id];

        int a_root = MICRO_ID_TO_INT(a_id);

        khiter_t k;

        for (;;) {

          k = kh_get(ccv_nnc_axis_id_group, axis_id_groups, a_root);

          if (k == kh_end(axis_id_groups))

            break;

          a_root = kh_val(axis_id_groups, k);

        }

        ccv_nnc_micro_id_t b_id = b_index.id;

        while (groups && groups[b_id.id] != b_id.id)

          b_id.id = groups[b_id.id];

        int b_root = MICRO_ID_TO_INT(b_id);

        for (;;) {

          k = kh_get(ccv_nnc_axis_id_group, axis_id_groups, b_root);

          if (k == kh_end(axis_id_groups))

            break;

          b_root = kh_val(axis_id_groups, k);

        }

        if (a_root == b_root)

          return 1;

      }

      if (groups && 
(556
a_index.id.type == CCV_NNC_MICRO_AXIS_SIZE_ID556
 || 
a_index.id.type == CCV_NNC_MICRO_TENSOR_ID168
))

      {

        if (a_index.id.d != b_index.id.d)

          return 0;

        switch (a_index.id.type)

        {

          case CCV_NNC_MICRO_TENSOR_ID:

          case CCV_NNC_MICRO_AXIS_SIZE_ID: {

            // Find their group identifier and then compare.

            int a_root = groups[a_index.id.id];

            while (groups[a_root] != a_root)

              a_root = groups[a_root];

            int b_root = groups[b_index.id.id];

            while (groups[b_root] != b_root)

              b_root = groups[b_root];

            return a_root == b_root;

          }

        }

        return a_index.id.id == b_index.id.id;

      } else

        return (a_index.id.d == b_index.id.d && 
a_index.id.id == b_index.id.id218
);

    case CCV_NNC_MICRO_LOOP_INDEX_TYPE_BINARY: {

      return a_index.binary->op == b_index.binary->op && _ccv_nnc_same_index_term(a_index.binary->left, b_index.binary->left, groups, axis_id_groups) && _ccv_nnc_same_index_term(a_index.binary->right, b_index.binary->right, groups, axis_id_groups);

    }

  }

  return 0;

}

static int _ccv_nnc_same_shape(const ccv_nnc_micro_loop_index_term_t* const a_shape, const ccv_nnc_micro_loop_index_term_t* const b_shape, const int dimensions)

{

  int i;

  for (i = 0; i < dimensions; 
i++30
)

    if (!_ccv_nnc_same_index_term(a_shape[i], b_shape[i], 0, 0))

      return 0;

  return 1;

}

static int _ccv_nnc_same_loop(const ccv_nnc_micro_loop_block_t* const left_block, const ccv_nnc_micro_loop_block_t* const right_block, const int* const groups, khash_t(ccv_nnc_axis_id_group)* const axis_id_groups, int* const left_loop_idx, int* const right_loop_idx)

{

  assert(left_block->loop_count > 0);

  assert(right_block->loop_count > 0);

  int i, j;

  int left_right_link[left_block->loop_count];

  int right_left_link[right_block->loop_count];

  enum {

    ONE = -2,

    UNASSIGNED = -1,

  };

  for (i = 0; i < left_block->loop_count; 
i++232
)

    if (left_block->loops[i].start_index.type == CCV_NNC_MICRO_LOOP_INDEX_TYPE_VAL && left_block->loops[i].start_index.immediate_value == 0 &&

      left_block->loops[i].end_index.type == CCV_NNC_MICRO_LOOP_INDEX_TYPE_VAL && 
left_block->loops[i].end_index.immediate_value == 10
)

      left_right_link[i] = ONE;

    else

      left_right_link[i] = UNASSIGNED;

  for (i = 0; i < right_block->loop_count; 
i++230
)

    if (right_block->loops[i].start_index.type == CCV_NNC_MICRO_LOOP_INDEX_TYPE_VAL && right_block->loops[i].start_index.immediate_value == 0 &&

      right_block->loops[i].end_index.type == CCV_NNC_MICRO_LOOP_INDEX_TYPE_VAL && 
right_block->loops[i].end_index.immediate_value == 10
)

      right_left_link[i] = ONE;

    else

      right_left_link[i] = UNASSIGNED;

  for (i = 0; i < left_block->loop_count; 
i++232
) // Find corresponding loop on the right.

  {

    if (left_right_link[i] != UNASSIGNED)

      continue;

    int flag = UNASSIGNED;

    for (j = 0; j < right_block->loop_count && 
flag == UNASSIGNED1.01k
; 
j++889
)

    {

      if (right_left_link[j] != UNASSIGNED)

        continue;

      if (_ccv_nnc_same_index_term(left_block->loops[i].start_index, right_block->loops[j].start_index, groups, axis_id_groups) && 

        _ccv_nnc_same_index_term(left_block->loops[i].end_index, right_block->loops[j].end_index, groups, axis_id_groups))

        flag = j;

    }

    if (flag != UNASSIGNED)

    {

      left_right_link[i] = flag;

      right_left_link[flag] = i;

    }

  }

  // If still have unmatched, they don't share the same loop.

  for (i = 0; i < left_block->loop_count; 
i++144
)

    if (left_right_link[i] == UNASSIGNED)

      return 0;

  
for (i = 0; 24
i < right_block->loop_count; 
i++144
)

    if (right_left_link[i] == UNASSIGNED)

      return 0;

  // I don't want to deal with constant loop, hence, if other than the outer-most is a constant loop (0..<1),

  // we cannot merge.

  
for (i = 1; 24
i < left_block->loop_count; 
i++120
)

    if (left_right_link[i] == ONE)

      return 0;

  
for (i = 1; 24
i < right_block->loop_count; 
i++120
)

    if (right_left_link[i] == ONE)

      return 0;

  assert((left_block->loop_count == right_block->loop_count) ||

      (left_block->loop_count == right_block->loop_count + 1) ||

      (left_block->loop_count + 1 == right_block->loop_count));

  // The loop matches, but the ordering probably doesn't. We reorder loop based on statements.

  // Hence, two loops can only merge if using the statements as a pivot point and they can still

  // match things before / after the statement.

  // If both have statements, check if order preserving within the statement loop (we can be fancier

  // and recursively call this while using statement as pivoting point, but that is too much to my taste).

  const int left_start_idx = left_right_link[0] == ONE ? 
10
 : 0;

  const int right_start_idx = right_left_link[0] == ONE ? 
10
 : 0;

  for (i = 0; i < left_block->loop_count; 
i++144
)

    left_loop_idx[i] = UNASSIGNED;

  for (i = 0; i < right_block->loop_count; 
i++144
)

    right_loop_idx[i] = UNASSIGNED;

  if (left_start_idx == 1)

    left_loop_idx[0] = 0; // Assign their index.

  if (right_start_idx == 0)

    right_loop_idx[0] = 0; // Assign their index.

  const int end_idx = left_right_link[0] == ONE && 
right_left_link[0] == ONE0
 ? 
left_block->loop_count - 10
 : ccv_min(left_block->loop_count, right_block->loop_count);

  int pivot_idx = end_idx;

  int k;

  for (i = end_idx - 1; i >= 0; 
i--144
)

  {

    if (left_block->loops[i + left_start_idx].statement_count > 0)

    {

      for (j = i + 1, k = i + 1; j < end_idx; 
j++0
)

        if (left_loop_idx[j + left_start_idx] == UNASSIGNED)

        {

          left_loop_idx[j + left_start_idx] = k + left_start_idx;

          // If the right one can be referenced pass previous pivot_idx, it is not right.

          if (left_right_link[j + left_start_idx] >= pivot_idx + right_start_idx)

            return 0;

          right_loop_idx[left_right_link[j + left_start_idx]] = k + right_start_idx;

          ++k;

          if (k > pivot_idx)

            return 0;

        }

      assert(k == pivot_idx);

      pivot_idx = i + 1;

    }

    if (right_block->loops[i + right_start_idx].statement_count > 0)

    {

      for (j = i + 1, k = i + 1; j < end_idx; 
j++7
)

        if (right_loop_idx[j + left_start_idx] == UNASSIGNED)

        {

          right_loop_idx[j + right_start_idx] = k + right_start_idx;

          // If the left one can be referenced pass previous pivot_idx, it is not right.

          if (right_left_link[j + right_start_idx] >= pivot_idx + left_start_idx)

            return 0;

          left_loop_idx[right_left_link[j + right_start_idx]] = k + left_start_idx;

          ++k;

          if (k > pivot_idx)

            return 0;

        }

      assert(k == pivot_idx);

      pivot_idx = i + 1;

    }

  }

  if (end_idx == 0)

    return 1;

  // Finally, to distribute the rest.

  
for (j = 0, k = 0; 24
j < end_idx; 
j++144
)

  {

    if (left_loop_idx[j + left_start_idx] == UNASSIGNED)

    {

      left_loop_idx[j + left_start_idx] = k + left_start_idx;

      // If the right one can be referenced pass previous pivot_idx, it is not right.

      if (left_right_link[j + left_start_idx] >= pivot_idx + right_start_idx)

        return 0;

      right_loop_idx[left_right_link[j + left_start_idx]] = k + right_start_idx;

      ++k;

      if (k > pivot_idx)

        return 0;

    }

  }

  assert(k == pivot_idx);

  return 1;

}

static void _ccv_nnc_loop_order_by(ccv_nnc_micro_loop_block_t* const block, int* const loop_idx, ccv_nnc_micro_loop_t* const loops)

{

  int i;

  for (i = 0; i < block->loop_count; 
i++288
)

    if (loop_idx[i] >= 0)

      loops[loop_idx[i]] = block->loops[i];

    else

      loops[i] = block->loops[i];

  for (i = 0; i < block->loop_count; 
i++288
)

  {

    // Essentially, we don't need to move statements, loop-carried variables, just the loop id and the start / end index.

    block->loops[i].id = loops[i].id;

    block->loops[i].start_index = loops[i].start_index;

    block->loops[i].end_index = loops[i].end_index;

  }

}

static void _ccv_nnc_expression_rename_carrieds(ccv_nnc_micro_loop_expression_t* const expression, const int start_idx)

{

  switch (expression->type)

  {

    case CCV_NNC_MICRO_LOOP_EXPR_TYPE_ID:

      assert(expression->id.type == CCV_NNC_MICRO_LOOP_CARRIED_ID);

      expression->id.id += start_idx;

      break;

    case CCV_NNC_MICRO_LOOP_EXPR_TYPE_TERNAY:

      _ccv_nnc_expression_rename_carrieds(expression->ternary.pivot, start_idx);

      _ccv_nnc_expression_rename_carrieds(expression->ternary.left, start_idx);

      _ccv_nnc_expression_rename_carrieds(expression->ternary.right, start_idx);

      break;

    case CCV_NNC_MICRO_LOOP_EXPR_TYPE_BINARY:

      _ccv_nnc_expression_rename_carrieds(expression->binary.left, start_idx);

      _ccv_nnc_expression_rename_carrieds(expression->binary.right, start_idx);

      break;

    case CCV_NNC_MICRO_LOOP_EXPR_TYPE_UNARY:

      _ccv_nnc_expression_rename_carrieds(expression->unary.x, start_idx);

      break;

    // We don't need to care about other expressions because loop-carried variable cannot participate these operations.

    case CCV_NNC_MICRO_LOOP_EXPR_TYPE_VAR:

      break;

  }

}

static void _ccv_nnc_loop_rename_carrieds(ccv_nnc_micro_loop_block_t* const block, const int start_idx)

{

  int i, j;

  const int loop_count = block->loop_count;

  ccv_nnc_micro_loop_t* const loops = block->loops;

  for (i = 0; i < loop_count; 
i++65
)

  {

    for (j = 0; j < loops[i].carried_count; 
j++0
)

      loops[i].carrieds[j].id.id += start_idx;

    for (j = 0; j < loops[i].statement_count; 
j++11
)

      switch (loops[i].statements[j].type)

      {

        case CCV_NNC_MICRO_LOOP_STATEMENT_TYPE_ASSIGNMENT:

          _ccv_nnc_expression_rename_carrieds(&loops[i].statements[j].compound_assignment.rvalue, start_idx);

          break;

        case CCV_NNC_MICRO_LOOP_STATEMENT_TYPE_COMPOUND_ASSIGNMENT:

          if (loops[i].statements[j].compound_assignment.lvalue.type == CCV_NNC_MICRO_LOOP_EXPR_TYPE_ID)

          {

            assert(loops[i].statements[j].compound_assignment.lvalue.id.type == CCV_NNC_MICRO_LOOP_CARRIED_ID);

            loops[i].statements[j].compound_assignment.lvalue.id.id += start_idx;

          }

          _ccv_nnc_expression_rename_carrieds(&loops[i].statements[j].compound_assignment.rvalue, start_idx);

          break;

      }

  }

}

static int _ccv_nnc_only_var_in_expression(const int id, const ccv_nnc_micro_loop_variable_t var, const ccv_nnc_micro_loop_expression_t* const expression, const int* const groups, khash_t(ccv_nnc_axis_id_group)* const axis_id_groups)

{

  switch (expression->type)

  {

    case CCV_NNC_MICRO_LOOP_EXPR_TYPE_VAR:

      if (expression->variable.id.type == CCV_NNC_MICRO_TENSOR_ID && expression->variable.id.id == id)

      {

        if (var.index_count != expression->variable.index_count)

          return 2;

        int i;

        for (i = 0; i < var.index_count; 
i++153
)

          if (!_ccv_nnc_same_index_term(var.index[i], expression->variable.index[i], groups, axis_id_groups))

            return 2;

        return 1;

      } else

        return 0;

    case CCV_NNC_MICRO_LOOP_EXPR_TYPE_TERNAY: {

      const int pivot = _ccv_nnc_only_var_in_expression(id, var, expression->ternary.pivot, groups, axis_id_groups);

      const int left = _ccv_nnc_only_var_in_expression(id, var, expression->ternary.left, groups, axis_id_groups);

      const int right = _ccv_nnc_only_var_in_expression(id, var, expression->ternary.right, groups, axis_id_groups);

      if (pivot == 2 || left == 2 || right == 2)

        return 2;

      return (pivot || left || right);

    }

    case CCV_NNC_MICRO_LOOP_EXPR_TYPE_BINARY: {

      const int left = _ccv_nnc_only_var_in_expression(id, var, expression->binary.left, groups, axis_id_groups);

      const int right = _ccv_nnc_only_var_in_expression(id, var, expression->binary.right, groups, axis_id_groups);

      if (left == 2 || right == 2)

        return 2;

      return (left || 
right51
);

    }

    case CCV_NNC_MICRO_LOOP_EXPR_TYPE_UNARY:

      return _ccv_nnc_only_var_in_expression(id, var, expression->unary.x, groups, axis_id_groups);

    case CCV_NNC_MICRO_LOOP_EXPR_TYPE_ID:

      assert(expression->id.type == CCV_NNC_MICRO_LOOP_CARRIED_ID);

      return 0;

  }

  return 0;

}

static int _ccv_nnc_only_var_in_rvalue(const int id, const ccv_nnc_micro_loop_variable_t var, const ccv_nnc_micro_loop_statement_t statement, const int* const groups, khash_t(ccv_nnc_axis_id_group)* const axis_id_groups)

{

  switch (statement.type)

  {

    case CCV_NNC_MICRO_LOOP_STATEMENT_TYPE_ASSIGNMENT:

      return _ccv_nnc_only_var_in_expression(id, var, &statement.assignment.rvalue, groups, axis_id_groups);

    case CCV_NNC_MICRO_LOOP_STATEMENT_TYPE_COMPOUND_ASSIGNMENT:

      return _ccv_nnc_only_var_in_expression(id, var, &statement.compound_assignment.rvalue, groups, axis_id_groups);

  }

  return 0;

}

static ccv_nnc_micro_loop_expression_t _ccv_nnc_expression_deep_copy(const ccv_nnc_micro_loop_expression_t* const expression)

{

  switch (expression->type)

  {

    case CCV_NNC_MICRO_LOOP_EXPR_TYPE_TERNAY: {

      ccv_nnc_micro_loop_expression_t copy = *expression;

      copy.ternary.pivot = (ccv_nnc_micro_loop_expression_t*)ccmalloc(sizeof(ccv_nnc_micro_loop_expression_t));

      *copy.ternary.pivot = _ccv_nnc_expression_deep_copy(expression->ternary.pivot);

      copy.ternary.left = (ccv_nnc_micro_loop_expression_t*)ccmalloc(sizeof(ccv_nnc_micro_loop_expression_t));

      *copy.ternary.left = _ccv_nnc_expression_deep_copy(expression->ternary.left);

      copy.ternary.right = (ccv_nnc_micro_loop_expression_t*)ccmalloc(sizeof(ccv_nnc_micro_loop_expression_t));

      *copy.ternary.right = _ccv_nnc_expression_deep_copy(expression->ternary.right);

      return copy;

    }

    case CCV_NNC_MICRO_LOOP_EXPR_TYPE_BINARY: {

      ccv_nnc_micro_loop_expression_t copy = *expression;

      copy.binary.left = (ccv_nnc_micro_loop_expression_t*)ccmalloc(sizeof(ccv_nnc_micro_loop_expression_t));

      *copy.binary.left = _ccv_nnc_expression_deep_copy(expression->binary.left);

      copy.binary.right = (ccv_nnc_micro_loop_expression_t*)ccmalloc(sizeof(ccv_nnc_micro_loop_expression_t));

      *copy.binary.right = _ccv_nnc_expression_deep_copy(expression->binary.right);

      return copy;

    }

    case CCV_NNC_MICRO_LOOP_EXPR_TYPE_UNARY: {

      ccv_nnc_micro_loop_expression_t copy = *expression;

      copy.unary.x = (ccv_nnc_micro_loop_expression_t*)ccmalloc(sizeof(ccv_nnc_micro_loop_expression_t));

      *copy.unary.x = _ccv_nnc_expression_deep_copy(expression->unary.x);

      return copy;

    }

    case CCV_NNC_MICRO_LOOP_EXPR_TYPE_VAR: {

      ccv_nnc_micro_loop_expression_t copy = *expression;

      int i;

      for (i = 0; i < copy.variable.index_count; 
i++17
)

        copy.variable.index[i] = ccv_nnc_micro_loop_index_deep_copy(&copy.variable.index[i]);

      return copy;

    }

    case CCV_NNC_MICRO_LOOP_EXPR_TYPE_ID:

      return *expression;

  }

  return *expression;

}

static void _ccv_nnc_replacing_id_in_expression(ccv_nnc_micro_loop_expression_t* const expression, const int id, ccv_nnc_micro_loop_expression_t rvalue, int* const count)

{

  switch (expression->type)

  {

    case CCV_NNC_MICRO_LOOP_EXPR_TYPE_VAR:

      if (expression->variable.id.type == CCV_NNC_MICRO_TENSOR_ID && expression->variable.id.id == id)

      {

        ccv_nnc_micro_loop_variable_free(&expression->variable);

        if (*count == 0) // First time, just assign to expression.

          *expression = rvalue;

        else // Otherwise, need to make deep copy of it.

          *expression = _ccv_nnc_expression_deep_copy(&rvalue);

        ++(*count);

      }

      break;

    case CCV_NNC_MICRO_LOOP_EXPR_TYPE_TERNAY:

      _ccv_nnc_replacing_id_in_expression(expression->ternary.pivot, id, rvalue, count);

      _ccv_nnc_replacing_id_in_expression(expression->ternary.left, id, rvalue, count);

      _ccv_nnc_replacing_id_in_expression(expression->ternary.right, id, rvalue, count);

      break;

    case CCV_NNC_MICRO_LOOP_EXPR_TYPE_BINARY:

      _ccv_nnc_replacing_id_in_expression(expression->binary.left, id, rvalue, count);

      _ccv_nnc_replacing_id_in_expression(expression->binary.right, id, rvalue, count);

      break;

    case CCV_NNC_MICRO_LOOP_EXPR_TYPE_UNARY:

      _ccv_nnc_replacing_id_in_expression(expression->unary.x, id, rvalue, count);

      break;

    case CCV_NNC_MICRO_LOOP_EXPR_TYPE_ID:

      assert(expression->id.type == CCV_NNC_MICRO_LOOP_CARRIED_ID);

      break;

  }

}

static void _ccv_nnc_replacing_id_in_rvalue(ccv_nnc_micro_loop_statement_t* const statement, const int id, ccv_nnc_micro_loop_expression_t rvalue, int* const count)

{

  switch (statement->type)

  {

    case CCV_NNC_MICRO_LOOP_STATEMENT_TYPE_ASSIGNMENT:

      _ccv_nnc_replacing_id_in_expression(&statement->assignment.rvalue, id, rvalue, count);

      break;

    case CCV_NNC_MICRO_LOOP_STATEMENT_TYPE_COMPOUND_ASSIGNMENT:

      // Not going to be in lvalue (which is the carried variable only).

      _ccv_nnc_replacing_id_in_expression(&statement->compound_assignment.rvalue, id, rvalue, count);

      break;

  }

}

typedef struct {

  int flag;

  int merge_to;

  ccv_array_t* writes;

  ccv_array_t* reads;

} ccv_nnc_micro_loop_block_dependency_t;

typedef struct {

  int flag;

  ccv_array_t* writes;

  ccv_array_t* reads;

} ccv_nnc_micro_tensor_dependency_t;

static void _ccv_nnc_micro_block_dependencies_from_rvalue(const ccv_nnc_micro_loop_expression_t* const rvalue, const int i, ccv_nnc_micro_loop_block_dependency_t* const block_dependencies, ccv_nnc_micro_tensor_dependency_t* const tensor_dependencies)

{

  switch (rvalue->type)

  {

    case CCV_NNC_MICRO_LOOP_EXPR_TYPE_VAR:

      if (rvalue->variable.id.type == CCV_NNC_MICRO_TENSOR_ID)

      {

        if (!block_dependencies[i].reads)

          block_dependencies[i].reads = ccv_array_new(sizeof(int), 1, 0);

        const int id = rvalue->variable.id.id;

        ccv_array_add_unique_int(block_dependencies[i].reads, id);

        if (!tensor_dependencies[id].reads)

          tensor_dependencies[id].reads = ccv_array_new(sizeof(int), 1, 0);

        ccv_array_add_unique_int(tensor_dependencies[id].reads, i);

      }

      break;

    case CCV_NNC_MICRO_LOOP_EXPR_TYPE_TERNAY:

      _ccv_nnc_micro_block_dependencies_from_rvalue(rvalue->ternary.pivot, i, block_dependencies, tensor_dependencies);

      _ccv_nnc_micro_block_dependencies_from_rvalue(rvalue->ternary.left, i, block_dependencies, tensor_dependencies);

      _ccv_nnc_micro_block_dependencies_from_rvalue(rvalue->ternary.right, i, block_dependencies, tensor_dependencies);

      break;

    case CCV_NNC_MICRO_LOOP_EXPR_TYPE_BINARY:

      _ccv_nnc_micro_block_dependencies_from_rvalue(rvalue->binary.left, i, block_dependencies, tensor_dependencies);

      _ccv_nnc_micro_block_dependencies_from_rvalue(rvalue->binary.right, i, block_dependencies, tensor_dependencies);

      break;

    case CCV_NNC_MICRO_LOOP_EXPR_TYPE_UNARY:

      _ccv_nnc_micro_block_dependencies_from_rvalue(rvalue->unary.x, i, block_dependencies, tensor_dependencies);

      break;

    case CCV_NNC_MICRO_LOOP_EXPR_TYPE_ID:

      assert(rvalue->id.type == CCV_NNC_MICRO_LOOP_CARRIED_ID);

      break;

  }

}

static void _ccv_nnc_micro_block_dependencies(const ccv_nnc_micro_loop_block_t* const blocks, const int block_size, const int var_count, ccv_nnc_micro_loop_block_dependency_t** const block_dependencies_ref, ccv_nnc_micro_tensor_dependency_t** const tensor_dependencies_ref)

{

  ccv_nnc_micro_loop_block_dependency_t* const block_dependencies = (ccv_nnc_micro_loop_block_dependency_t*)cccalloc(block_size, sizeof(ccv_nnc_micro_loop_block_dependency_t));

  ccv_nnc_micro_tensor_dependency_t* const tensor_dependencies = (ccv_nnc_micro_tensor_dependency_t*)cccalloc(var_count, sizeof(ccv_nnc_micro_tensor_dependency_t));

  int i, j, k;

  for (i = 0; i < block_size; 
i++45
)

  {

    block_dependencies[i].merge_to = i;

    const ccv_nnc_micro_loop_t* const loops = blocks[i].loops;

    const int loop_count = blocks[i].loop_count;

    for (j = 0; j < loop_count; 
j++241
)

    {

      const ccv_nnc_micro_loop_statement_t* const statements = loops[j].statements;

      const int statement_count = loops[j].statement_count;

      for (k = 0; k < statement_count; 
k++51
)

        switch (statements[k].type)

        {

          case CCV_NNC_MICRO_LOOP_STATEMENT_TYPE_ASSIGNMENT: {

            assert(statements[k].assignment.lvalue.id.type == CCV_NNC_MICRO_TENSOR_ID);

            const int id = statements[k].assignment.lvalue.id.id;

            if (!block_dependencies[i].writes)

              block_dependencies[i].writes = ccv_array_new(sizeof(int), 1, 0);

            ccv_array_add_unique_int(block_dependencies[i].writes, id);

            if (!tensor_dependencies[id].writes)

              tensor_dependencies[id].writes = ccv_array_new(sizeof(int), 1, 0);

            ccv_array_add_unique_int(tensor_dependencies[id].writes, i);

            _ccv_nnc_micro_block_dependencies_from_rvalue(&statements[k].assignment.rvalue, i, block_dependencies, tensor_dependencies);

            break;

          }

          case CCV_NNC_MICRO_LOOP_STATEMENT_TYPE_COMPOUND_ASSIGNMENT: {

            if (statements[k].compound_assignment.lvalue.type == CCV_NNC_MICRO_LOOP_EXPR_TYPE_VAR)

            {

              assert(statements[k].compound_assignment.lvalue.id.type == CCV_NNC_MICRO_TENSOR_ID);

              const int id = statements[k].compound_assignment.lvalue.id.id;

              if (!block_dependencies[i].writes)

                block_dependencies[i].writes = ccv_array_new(sizeof(int), 1, 0);

              ccv_array_add_unique_int(block_dependencies[i].writes, id);

              if (!tensor_dependencies[id].writes)

                tensor_dependencies[id].writes = ccv_array_new(sizeof(int), 1, 0);

              ccv_array_add_unique_int(tensor_dependencies[id].writes, i);

              if (!block_dependencies[i].reads)

                block_dependencies[i].reads = ccv_array_new(sizeof(int), 1, 0);

              ccv_array_add_unique_int(block_dependencies[i].reads, id);

              if (!tensor_dependencies[id].reads)

                tensor_dependencies[id].reads = ccv_array_new(sizeof(int), 1, 0);

              ccv_array_add_unique_int(tensor_dependencies[id].reads, i);

            }

            _ccv_nnc_micro_block_dependencies_from_rvalue(&statements[k].compound_assignment.rvalue, i, block_dependencies, tensor_dependencies);

            break;

          }

        }

    }

  }

  *block_dependencies_ref = block_dependencies;

  *tensor_dependencies_ref = tensor_dependencies;

}

static void _ccv_nnc_micro_dependencies_free(ccv_nnc_micro_loop_block_dependency_t* const block_dependencies, const int block_size, ccv_nnc_micro_tensor_dependency_t* const tensor_dependencies, const int var_count)

{

  int i;

  for (i = 0; i < block_size; 
i++45
)

  {

    if (block_dependencies[i].writes)

      ccv_array_free(block_dependencies[i].writes);

    if (block_dependencies[i].reads)

      ccv_array_free(block_dependencies[i].reads);

  }

  ccfree(block_dependencies);

  for (i = 0; i < var_count; 
i++54
)

  {

    if (tensor_dependencies[i].writes)

      ccv_array_free(tensor_dependencies[i].writes);

    if (tensor_dependencies[i].reads)

      ccv_array_free(tensor_dependencies[i].reads);

  }

  ccfree(tensor_dependencies);

}

static int _ccv_nnc_tensor_reads_in_y_from_writes_after_x(const ccv_nnc_micro_loop_block_dependency_t* const block_dependencies, const ccv_nnc_micro_tensor_dependency_t* const tensor_dependencies, const int x, const int y)

{

  int i, j;

  int flag = 0;

  for (i = 0; !flag && 
i < block_dependencies[y].reads->rnum53
; 
i++38
)

  {

    const int read_idx = *(int*)ccv_array_get(block_dependencies[y].reads, i);

    if (tensor_dependencies[read_idx].writes)

      
for (j = 0; 34
!flag && 
j < tensor_dependencies[read_idx].writes->rnum53
; 
j++34
)

      {

        int block_idx = *(int*)ccv_array_get(tensor_dependencies[read_idx].writes, j);

        while (block_idx != block_dependencies[block_idx].merge_to)

          block_idx = block_dependencies[block_idx].merge_to;

        if (!block_dependencies[block_idx].flag) // Not in use, continue.

          continue;

        assert(block_idx <= y);

        // If the block_idx is between i and j (and not neither). We cannot merge.

        if (block_idx > x && 
block_idx != y15
)

          flag = block_idx;

      }

  }

  return flag;

}

static int _ccv_nnc_tensor_writes_in_x_reads_before_y(const ccv_nnc_micro_loop_block_dependency_t* const block_dependencies, const ccv_nnc_micro_tensor_dependency_t* const tensor_dependencies, const int x, const int y)

{

  int i, j;

  int flag = 0;

  for (i = 0; !flag && 
i < block_dependencies[x].writes->rnum48
; 
i++40
)

  {

    const int write_idx = *(int*)ccv_array_get(block_dependencies[x].writes, i);

    if (tensor_dependencies[write_idx].reads)

      
for (j = 0; 40
!flag && 
j < tensor_dependencies[write_idx].reads->rnum93
; 
j++60
)

      {

        int block_idx = *(int*)ccv_array_get(tensor_dependencies[write_idx].reads, j);

        while (block_idx != block_dependencies[block_idx].merge_to)

          block_idx = block_dependencies[block_idx].merge_to;

        if (!block_dependencies[block_idx].flag) // Not in use, continue.

          continue;

        assert(block_idx >= x);

        // If the block_idx is between i and j (and not neither). We cannot merge.

        if (block_idx < y && 
block_idx != x35
)

          flag = block_idx;

      }

  }

  return flag;

}

static void _ccv_nnc_tensor_remove_dead_store(const ccv_nnc_micro_tensor_dependency_t* const tensor_dependency, const int tensor_idx, ccv_array_t* const blocks)

{

  int i, j, k, l;;

  if (tensor_dependency->writes)

    
for (i = 0; 6
i < tensor_dependency->writes->rnum; 
i++6
)

    {

      const int write_idx = *(int*)ccv_array_get(tensor_dependency->writes, i);

      ccv_nnc_micro_loop_block_t* const block = (ccv_nnc_micro_loop_block_t*)ccv_array_get(blocks, write_idx);

      int flag = 0;

      for (j = 0; j < block->loop_count; 
j++0
)

      {

        ccv_nnc_micro_loop_statement_t* const statements = block->loops[j].statements;

        for (k = 0, l = 0; k < block->loops[j].statement_count; k++)

        {

          // It cannot be compound assignment, in this case, this tensor will be in read, and

          // it will be in active use (anything "read" in an active block will be marked as in use).

          assert(!(statements[k].type == CCV_NNC_MICRO_LOOP_STATEMENT_TYPE_COMPOUND_ASSIGNMENT &&

            statements[k].compound_assignment.lvalue.id.type == CCV_NNC_MICRO_TENSOR_ID &&

            statements[k].compound_assignment.lvalue.id.id == tensor_idx));

          if (statements[k].type == CCV_NNC_MICRO_LOOP_STATEMENT_TYPE_ASSIGNMENT &&

            statements[k].assignment.lvalue.id.type == CCV_NNC_MICRO_TENSOR_ID &&

            statements[k].assignment.lvalue.id.id == tensor_idx)

          {

            // This is a dead store, prepare to remove.

            ccv_nnc_micro_loop_statement_free(&statements[k]);

          } else {

            statements[l] = statements[k];

            ++l;

          }

        }

        if (l < block->loops[j].statement_count)

        {

          if (l > 0)

            block->loops[j].statements = (ccv_nnc_micro_loop_statement_t*)ccrealloc(block->loops[j].statements, sizeof(ccv_nnc_micro_loop_statement_t) * l);

          else {

            ccfree(block->loops[j].statements);

            block->loops[j].statements = 0;

          }

          block->loops[j].statement_count = 0;

        }

        if (block->loops[j].statement_count > 0)

          flag = 1;

      }

      if (!flag) // No statement for this block, remove this whole block.

      {

        ccv_nnc_micro_loops_free(block->loops, block->loop_count);

        ccfree(block->loops);

        block->loops = 0;

        block->loop_count = 0;

      }

    }

}

static void _ccv_nnc_loop_merging(ccv_nnc_micro_loop_block_dependency_t* const block_dependencies, const ccv_nnc_micro_tensor_dependency_t* const tensor_dependencies, ccv_array_t* const blocks, const int max_loop_count, const int* const groups, khash_t(ccv_nnc_axis_id_group)* const axis_id_groups)

{

  int i, j;

  int left_loop_idx[max_loop_count];

  int right_loop_idx[max_loop_count];

  ccv_nnc_micro_loop_t loops[max_loop_count];

  // Merge loops from blocks.

  for (i = 0; i < blocks->rnum - 1; 
i++39
)

  {

    ccv_nnc_micro_loop_block_t* const left_block = (ccv_nnc_micro_loop_block_t*)ccv_array_get(blocks, i);

    if (left_block->loop_count == 0)

      continue;

    
for (j = i + 1; 17
j < blocks->rnum; 
j++57
)

    {

      // We always merge from right block to left block. Thus, the right block will always be

      // in the original form.

      ccv_nnc_micro_loop_block_t* const right_block = (ccv_nnc_micro_loop_block_t*)ccv_array_get(blocks, j);

      if (right_block->loop_count == 0)

        continue;

      int merge_to_right = 0;

      // First check whether between left and right, there are any blocks that the right block

      // depends on. If that is the case, we cannot merge the right block into the left block.

      if (j > i + 1 && 
block_dependencies[j].reads38
)

      {

        const int block_idx = _ccv_nnc_tensor_reads_in_y_from_writes_after_x(block_dependencies, tensor_dependencies, i, j);

        // Cannot merge because we have dependencies in between. Merging will violate that

        // dependency relationship.

        if (block_idx)

        {

          // Now check to see if left can be merged into right? If so, we are lucky.

          if (_ccv_nnc_tensor_writes_in_x_reads_before_y(block_dependencies, tensor_dependencies, i, j))

            continue;

          merge_to_right = 1;

        }

      }

      // This method not only compares whether they have the same loop or not, but also gives indexes that

      // to match the loop start / end index, where they should move to. For example, if:

      // left_loop_idx[2] = 3

      // right_loop_idx[0] = 3

      // That means right now, loop at index 2 on the left is the same as loop at index 0 on the right.

      // And to match exactly, they both need to move to index 3.

      if (_ccv_nnc_same_loop(left_block, right_block, groups, axis_id_groups, left_loop_idx, right_loop_idx))

      {

        // Make sure if we have extra loop, they are on the left.

        if (right_block->loop_count > left_block->loop_count)

        {

          ccv_nnc_micro_loop_block_t t;

          CCV_SWAP(*left_block, *right_block, t);

        }

        assert(left_block->loop_count == right_block->loop_count || left_block->loop_count == right_block->loop_count + 1);

        _ccv_nnc_loop_order_by(left_block, left_loop_idx, loops);

        _ccv_nnc_loop_order_by(right_block, right_loop_idx, loops);

        const int left_start_idx = left_block->loop_count - right_block->loop_count;

        if (left_block->carried_count > 0)

          _ccv_nnc_loop_rename_carrieds(right_block, left_block->carried_count);

        left_block->carried_count += right_block->carried_count;

        int k;

        for (k = 0; k < right_block->loop_count; 
k++144
) // Merge loops.

        {

          const int left_idx = left_start_idx + k;

          if (right_block->loops[k].carried_count > 0)

          {

            if (left_block->loops[left_idx].carried_count > 0)

            {

              left_block->loops[left_idx].carrieds = (ccv_nnc_micro_loop_carried_t*)ccrealloc(left_block->loops[left_idx].carrieds, sizeof(ccv_nnc_micro_loop_carried_t) * (left_block->loops[left_idx].carried_count + right_block->loops[k].carried_count));

              memcpy(left_block->loops[left_idx].carrieds + left_block->loops[left_idx].carried_count, right_block->loops[k].carrieds, sizeof(ccv_nnc_micro_loop_carried_t) * right_block->loops[k].carried_count);

              ccfree(right_block->loops[k].carrieds);

            } else

              left_block->loops[left_idx].carrieds = right_block->loops[k].carrieds;

            left_block->loops[left_idx].carried_count += right_block->loops[k].carried_count;

            right_block->loops[k].carrieds = 0;

            right_block->loops[k].carried_count = 0;

          }

          if (right_block->loops[k].statement_count > 0)

          {

            if (left_block->loops[left_idx].statement_count > 0)

            {

              left_block->loops[left_idx].statements = (ccv_nnc_micro_loop_statement_t*)ccrealloc(left_block->loops[left_idx].statements, sizeof(ccv_nnc_micro_loop_statement_t) * (left_block->loops[left_idx].statement_count + right_block->loops[k].statement_count));

              memcpy(left_block->loops[left_idx].statements + left_block->loops[left_idx].statement_count, right_block->loops[k].statements, sizeof(ccv_nnc_micro_loop_statement_t) * right_block->loops[k].statement_count);

              ccfree(right_block->loops[k].statements);

            } else

              left_block->loops[left_idx].statements = right_block->loops[k].statements;

            left_block->loops[left_idx].statement_count += right_block->loops[k].statement_count;

            right_block->loops[k].statements = 0;

            right_block->loops[k].statement_count = 0;

          }

        }

        // Once merged, free the loop.

        ccfree(right_block->loops);

        right_block->loops = 0;

        right_block->loop_count = 0;

        int x = i, y = j;

        if (merge_to_right) // If this is merge to right.

        {

          ccv_nnc_micro_loop_block_t t;

          CCV_SWAP(*left_block, *right_block, t);

          x = j, y = i;

        }

        // Merge all reads and writes tensors into block dependency.

        if (block_dependencies[y].writes && block_dependencies[y].writes->rnum)

        {

          if (!block_dependencies[x].writes)

            block_dependencies[x].writes = ccv_array_new(sizeof(int), 1, 0);

          for (k = 0; k < block_dependencies[y].writes->rnum; 
k++45
)

            ccv_array_push(block_dependencies[x].writes, ccv_array_get(block_dependencies[y].writes, k));

        }

        if (block_dependencies[y].reads && block_dependencies[y].reads->rnum)

        {

          if (!block_dependencies[x].reads)

            block_dependencies[x].reads = ccv_array_new(sizeof(int), 1, 0);

          for (k = 0; k < block_dependencies[y].reads->rnum; 
k++66
)

            ccv_array_push(block_dependencies[x].reads, ccv_array_get(block_dependencies[y].reads, k));

        }

        // Merged, mark the proper merging dependency.

        block_dependencies[y].merge_to = x;

        if (merge_to_right) // If this is merge to right, now left is empty, break.

          break;

      }

    }

  }

}

static void _ccv_nnc_var_subst(ccv_nnc_micro_tensor_t* const vars, const int var_count, const ccv_nnc_micro_io_t* const inputs, const int input_size, const ccv_nnc_micro_io_t* const outputs, const int output_size, ccv_array_t* const blocks, const int* const groups, khash_t(ccv_nnc_axis_id_group)* const axis_id_groups)

{

  int i, j;

  // These are simple programs, so we are going to loop over all blocks to see whether a non-output-input

  // var only write / read in one loop. If that is the case, we are going to remove that var.

  // We have to do this replacement from bottom to top though.

  for (i = 0; i < var_count; 
i++54
)

  {

    int flag = 0;

    for (j = 0; !flag && 
j < input_size171
; 
j++132
)

      flag = (inputs[j]->id == i);

    for (j = 0; !flag && 
j < output_size93
; 
j++63
)

      flag = (outputs[j]->id == i);

    if (flag) // This is in outputs or inputs.

      continue;

    int count_var = 0;

    ccv_nnc_micro_loop_variable_t lvalue;

    ccv_nnc_micro_loop_expression_t rvalue;

    int block_idx, loop_idx, statement_idx;

    for (j = 0; j < blocks->rnum; 
j++89
)

    {

      const ccv_nnc_micro_loop_block_t* const block = (ccv_nnc_micro_loop_block_t*)ccv_array_get(blocks, j);

      int k, l;

      const int loop_count = block->loop_count;

      const ccv_nnc_micro_loop_t* const loops = block->loops;

      int var_per_block = 0;

      for (k = 0; k < loop_count; 
k++361
)

      {

        int flag = 0;

        const int statement_count = loops[k].statement_count;

        ccv_nnc_micro_loop_statement_t* const statements = loops[k].statements;

        for (l = 0; l < statement_count; 
l++191
)

          if (statements[l].type == CCV_NNC_MICRO_LOOP_STATEMENT_TYPE_ASSIGNMENT &&

            
statements[l].assignment.lvalue.id.type == CCV_NNC_MICRO_TENSOR_ID140
 &&

            
statements[l].assignment.lvalue.id.id == i140
)

          {

            lvalue = statements[l].assignment.lvalue;

            if (_ccv_nnc_only_var_in_rvalue(i, lvalue, statements[l], groups, axis_id_groups))

              flag = 2;

            else {

              // If the variable not showing up on the right-side, we can continue.

              rvalue = statements[l].assignment.rvalue;

              block_idx = j;

              loop_idx = k;

              statement_idx = l;

              ++flag;

            }

          } else if (statements[l].type == CCV_NNC_MICRO_LOOP_STATEMENT_TYPE_COMPOUND_ASSIGNMENT &&

            
statements[l].compound_assignment.lvalue.id.type == CCV_NNC_MICRO_TENSOR_ID51
 &&

            
statements[l].compound_assignment.lvalue.id.id == i42
) {

            // This is compound assignment, automatically increase by 2.

            flag += 2;

          }

        if (flag > 1) // We have more than 1 assignment for this id, it is not good. We cannot remove it.

        {

          var_per_block += flag;

          continue;

        }

        
for (l = 0; 361
l < statement_count; 
l++191
)

          flag = ccv_max(flag, _ccv_nnc_only_var_in_rvalue(i, lvalue, statements[l], groups, axis_id_groups));

        // If flag == 2, meaning it found a var with a different index. This is a bad news.

        var_per_block += flag;

      }

      count_var += var_per_block;

    }

    // If this is used more than one place (write multiple times, have different index, or used in different blocks),

    // I cannot get rid of it.

    if (count_var != 1)

      continue;

    // Otherwise, now loop again and prepare to get rid of it.

    ccv_nnc_micro_loop_block_t* const block = (ccv_nnc_micro_loop_block_t*)ccv_array_get(blocks, block_idx);

    ccv_nnc_micro_loop_statement_t* statements = block->loops[loop_idx].statements;

    ccv_nnc_micro_loop_statement_t statement = statements[statement_idx];

    // First, remove the assignment.

    if (statement_idx < block->loops[loop_idx].statement_count - 1)

      memmove(statements + statement_idx, statements + statement_idx + 1, sizeof(ccv_nnc_micro_loop_statement_t) * (block->loops[loop_idx].statement_count - statement_idx - 1));

    --block->loops[loop_idx].statement_count;

    const int statement_count = block->loops[loop_idx].statement_count;

    statements = block->loops[loop_idx].statements = (ccv_nnc_micro_loop_statement_t*)ccrealloc(statements, sizeof(ccv_nnc_micro_loop_statement_t) * statement_count);

    int k = 0;

    for (j = 0; j < statement_count; 
j++64
)

      _ccv_nnc_replacing_id_in_rvalue(&statements[j], i, rvalue, &k);

    if (k == 0) // If nothing to replace, free up everything.

      ccv_nnc_micro_loop_statement_free(&statement);

    else

      ccv_nnc_micro_loop_statement_lvalue_free(&statement);

    // No need to allocate for this var. It is not used, only useful for shape computation.

    vars[i].no_alloc = 1;

  }

}

static int _ccv_nnc_index_binary_size(const ccv_nnc_micro_loop_index_term_t index)

{

  switch (index.type)

  {

    case CCV_NNC_MICRO_LOOP_INDEX_TYPE_NONE:

      return 0;

    case CCV_NNC_MICRO_LOOP_INDEX_TYPE_VAL:

    case CCV_NNC_MICRO_LOOP_INDEX_TYPE_ID:

      return 1;

    case CCV_NNC_MICRO_LOOP_INDEX_TYPE_BINARY:

      if (index.binary->op == CCV_NNC_MICRO_BINARY_OP_PLUS || 
index.binary->op == CCV_NNC_MICRO_BINARY_OP_MINUS48
)

        return _ccv_nnc_index_binary_size(index.binary->left) + _ccv_nnc_index_binary_size(index.binary->right);

      else

        return 1;

  }

  return 0;

}

typedef struct {

  int sign:7;

  int ignore:1;

  ccv_nnc_micro_loop_index_term_t term;

} ccv_nnc_micro_loop_binary_term_t;

static void _ccv_nnc_index_term_flatten(ccv_nnc_micro_loop_binary_term_t* const binary_terms, const ccv_nnc_micro_loop_index_term_t index, const int sign, int* const i)

{

  switch (index.type)

  {

    case CCV_NNC_MICRO_LOOP_INDEX_TYPE_NONE: // No need to occupy.

      break;

    case CCV_NNC_MICRO_LOOP_INDEX_TYPE_VAL:

    case CCV_NNC_MICRO_LOOP_INDEX_TYPE_ID:

      binary_terms[*i].term = index;

      binary_terms[*i].sign = sign;

      binary_terms[*i].ignore = 0;

      ++(*i);

      break;

    case CCV_NNC_MICRO_LOOP_INDEX_TYPE_BINARY:

      if (index.binary->op == CCV_NNC_MICRO_BINARY_OP_PLUS || 
index.binary->op == CCV_NNC_MICRO_BINARY_OP_MINUS48
)

      {

        _ccv_nnc_index_term_flatten(binary_terms, index.binary->left, sign, i);

        if (index.binary->op == CCV_NNC_MICRO_BINARY_OP_MINUS) // Switch sign.

          _ccv_nnc_index_term_flatten(binary_terms, index.binary->right, sign == CCV_NNC_MICRO_BINARY_OP_PLUS ? CCV_NNC_MICRO_BINARY_OP_MINUS : 
CCV_NNC_MICRO_BINARY_OP_PLUS0
, i);

        else

          _ccv_nnc_index_term_flatten(binary_terms, index.binary->right, sign, i);

      } else {

        binary_terms[*i].term = index;

        binary_terms[*i].sign = sign;

        binary_terms[*i].ignore = 0;

        ++(*i);

      }

      break;

  }

}

// 0 is we don't understand, -1 is false, 1 is true.

static int _ccv_nnc_index_less_than_or_equal_to(const ccv_nnc_micro_loop_index_term_t left, const ccv_nnc_micro_loop_index_term_t right, const ccv_nnc_micro_tensor_t* const vars, const int var_count, const int* const groups, khash_t(ccv_nnc_axis_id_group)* const axis_id_groups)

{

  // Special case 1.

  if (left.type == CCV_NNC_MICRO_LOOP_INDEX_TYPE_VAL && 
right.type == CCV_NNC_MICRO_LOOP_INDEX_TYPE_VAL128
)

    return left.immediate_value <= right.immediate_value ? 1 : 
-10
;

  // Special case 2.

  if (left.type == CCV_NNC_MICRO_LOOP_INDEX_TYPE_VAL && 
left.immediate_value == 00
 && 
right.type == CCV_NNC_MICRO_LOOP_INDEX_TYPE_ID0
 && 
right.id.type == CCV_NNC_MICRO_AXIS_SIZE_ID0
)

    return 1;

  // Special case 3.

  if (left.type == CCV_NNC_MICRO_LOOP_INDEX_TYPE_ID && 
left.id.type == CCV_NNC_MICRO_AXIS_SIZE_ID104
 && 
right.type == CCV_NNC_MICRO_LOOP_INDEX_TYPE_VAL92
 && 
right.immediate_value == 00
)

    return -1;

  // Now, we only have one variable in both left and right, need to flat the binary tree (if possible) and reduce it to constant if possible.

  // We can only flatten if it is + / - at the moment.

  const int left_binary_size = _ccv_nnc_index_binary_size(left);

  assert(left_binary_size >= 1);

  const int right_binary_size = _ccv_nnc_index_binary_size(right);

  assert(right_binary_size >= 1);

  ccv_nnc_micro_loop_binary_term_t* const left_binary_terms = (ccv_nnc_micro_loop_binary_term_t*)ccmalloc(sizeof(ccv_nnc_micro_loop_binary_term_t) * (left_binary_size + right_binary_size));

  ccv_nnc_micro_loop_binary_term_t* const right_binary_terms = left_binary_terms + left_binary_size;

  int i, j;

  i = 0;

  _ccv_nnc_index_term_flatten(left_binary_terms, left, CCV_NNC_MICRO_BINARY_OP_PLUS, &i);

  assert(i == left_binary_size);

  i = 0;

  _ccv_nnc_index_term_flatten(right_binary_terms, right, CCV_NNC_MICRO_BINARY_OP_PLUS, &i);

  assert(i == right_binary_size);

  // Matching signs in left terms.