// File: /workspace/github_cpp_makefile_star2_O1/iu-vail[P]iprimal/iPrimal.cpp
// Function: Primal::DualUpdates(_cell&, std::queue<_tree_node*, std::deque<_tree_node*, std::allocator<_tree_node*>>>&)
int
Primal::DualUpdates(cell& _start_cell, queue<tree_node*>& _bfs){

  // search the epsilon (minimal value) for varibles adjustments
  // it must satisfy 3 conditions: 
  // 1. >=0 in oprt_matrix; 2. in exploited rows; 3. in un-exploited cols

  // define and init epsilon as a largest positive value
  double epsilon = std::numeric_limits<double>::infinity();
  bool updated_epsilon = false;

#ifdef USE_HEAP

  /**** lines below are version using min-heaps, relatively faster ****/
  // search for min epsilon
  for(uint row_index=0; row_index<row_size; row_index++){
    if(exploited_rows.find(row_index) != exploited_rows.end()){
      //expose the first unvisited entry
      while(!min_heaps[row_index].empty()){ 
	if(exploited_cols.find(min_heaps[row_index].top().first) != exploited_cols.end())
	  min_heaps[row_index].pop();
        else
	  break;
      }
      if(!min_heaps[row_index].empty()){
        double cell_val = min_heaps[row_index].top().second + deltas[min_heaps[row_index].top().first] - deltas[GetAssignedCol(row_index)];
        if(cell_val < epsilon){
	  epsilon = cell_val;
          updated_epsilon = true;
        }
      }//if !min
    }//if exploited row
  }//for row_index

  // one more round traversal to find all qualified entries
  queue<cell> tmp_q;
  cell qual_c;
  if(updated_epsilon){
    for(uint row_index=0; row_index<row_size; row_index++)
      if(exploited_rows.find(row_index) != exploited_rows.end()){
        while(!min_heaps[row_index].empty()){ 
	  if(exploited_cols.find(min_heaps[row_index].top().first) != exploited_cols.end()){
            min_heaps[row_index].pop();
          }
          else{
            double cell_val = min_heaps[row_index].top().second + deltas[min_heaps[row_index].top().first] - deltas[GetAssignedCol(row_index)];
            if(fabs(cell_val - epsilon)<DOUBLE_EPSILON){
              qual_c.row_idx = row_index;
	      qual_c.col_idx = min_heaps[row_index].top().first;
              tmp_q.push(qual_c);
	      //this entry will be colored as visited later, so remove it here
	      // and this also expose next available entry for judging
	      min_heaps[row_index].pop();
            }
	    else if( cell_val - epsilon > DOUBLE_EPSILON){
              // stop at encountering the first uncolored entry that > epsilon
	      break;
	    }
            else {
	      cerr<<"Very weired thing happens."<<endl;
	      assert(0);
            }
          }//else
        }//while
      }//if exploited rows
  }//if updated epsilon

#else

  /**** lines below are version NOT using min-heaps, relatively slower ****/
  for(uint row_index=0; row_index<row_size; row_index++)
    if(exploited_rows.find(row_index) != exploited_rows.end())
      for(uint col_index=0; col_index<col_size; col_index++)
        if(exploited_cols.find(col_index) == exploited_cols.end()){
	  //double cell_val = oprt_matrix[row_index][col_index] - deltas[col_index];
	  double cell_val = oprt_matrix[row_index][col_index] + deltas[col_index] - deltas[GetAssignedCol(row_index)];
          if(cell_val > 0 && cell_val < epsilon){
            epsilon = cell_val;
            updated_epsilon = true;
          }
        }

  // one more round traversal to find all qualified entries
  queue<cell> tmp_q;
  cell qual_c;
  if(updated_epsilon){
    for(uint row_index=0; row_index<row_size; row_index++)
      if(exploited_rows.find(row_index) != exploited_rows.end())
        for(uint col_index=0; col_index<col_size; col_index++)
          if(exploited_cols.find(col_index) == exploited_cols.end()){
	    double cell_val = oprt_matrix[row_index][col_index] + deltas[col_index] - deltas[GetAssignedCol(row_index)];
            if(fabs(cell_val - epsilon)<DOUBLE_EPSILON){
              qual_c.row_idx = row_index;
	      qual_c.col_idx = col_index;
              tmp_q.push(qual_c);
            }
          }
  }//if

#endif

  // if found nothing, i.e., all available entries are <=0, leaving a void set
  if(!updated_epsilon)
    epsilon = - (oprt_matrix[_start_cell.row_idx][_start_cell.col_idx] 
		+ deltas[_start_cell.col_idx] - deltas[GetAssignedCol(_start_cell.row_idx)]);
  assert(epsilon > 0 && epsilon < std::numeric_limits<double>::infinity());

  _cout("# epsilon: "<<epsilon<<endl);

  // delta update
  for(uint col_index=0; col_index<col_size; col_index++)
    if(exploited_cols.find(col_index) != exploited_cols.end())
      deltas[col_index] += epsilon;  

  _cout("Updated deltas: "<<endl);
  DisplayVec<double>(deltas);

  vector<double> tmp_d(row_size);
  
  for(uint row_index=0; row_index<row_size; row_index++){
    tmp_d[row_index] = oprt_matrix[row_index][_start_cell.col_idx] + deltas[_start_cell.col_idx] - deltas[GetAssignedCol(row_index)];
  }

  _cout("Updated column ["<<_start_cell.col_idx<<"]:"<<endl);
  DisplayVec<double>(tmp_d);

  double min_d = std::numeric_limits<double>::infinity();
  uint new_start_row = row_size;
  for(uint i=0; i<row_size; i++)
    if(tmp_d[i] < min_d){ 
      min_d = tmp_d[i];
      new_start_row = i;
    }
  assert(new_start_row != row_size);
  _cout("Updated root: ("<<new_start_row<<", "<<_start_cell.col_idx<<")"<<endl);

  //terminate this stage if conditions below occur
  if(min_d >= 0){
    _cout("No loop, but the whole column is feasible!"<<endl);
    swap_loop.clear();

    return 0;
  }
  else if(new_start_row !=(uint)_start_cell.row_idx)
    if(exploited_rows.find(new_start_row) != exploited_rows.end()){
      _cout("Loop already exists!"<<endl);
      //update the starting cell
      _start_cell.row_idx = new_start_row;
      //now search the loop or notify the upper funciton to search it
      assert(asgn_ptrs[new_start_row]!=NULL);
      tree_node* tmp_ptr = asgn_ptrs[new_start_row];
      swap_loop.clear();
      while(tmp_ptr->asgn != -1){
        swap_loop.push_back(tmp_ptr->c);
        tmp_ptr=tmp_ptr->parent;
      }
      //finally append the updated root 
      swap_loop.push_back(_start_cell); 

      return 1;
    }
 
  while(!tmp_q.empty()){
    cell cur_c = tmp_q.front();
    tmp_q.pop();
    tree_node* p_cur_tree_node = asgn_ptrs[cur_c.row_idx];
    _cout("Current dead-end entry is: ("<<p_cur_tree_node->c.row_idx<<", "<<p_cur_tree_node->c.col_idx<<")"<<endl);
/*
    for(uint col_index=0; col_index<col_size; col_index++){
      //if(exploited_cols.find(col_index) == exploited_cols.end() && oprt_matrix[epsilon_row_idx][col_index] == oprt_matrix[epsilon_row_idx][epsilon_col_idx] ){
      if(fabs(oprt_matrix[epsilon_row_idx][col_index] + deltas[col_index] - deltas[GetAssignedCol(epsilon_row_idx)]) < DOUBLE_EPSILON
                && exploited_cols.find(col_index) == exploited_cols.end()
                && col_index != (uint)p_cur_tree_node->c.col_idx){
          //current new cell
          cell cur_c;
          cur_c.row_idx = epsilon_row_idx;
          cur_c.col_idx = col_index;
*/
          _cout("  found a new 0: ("
	  	<<cur_c.row_idx<<", "<<cur_c.col_idx<<")"<<endl);

	  //create a new tree_node
          tree_node* new_tree_node = new tree_node;
	  new_tree_node->c = cur_c;
	  new_tree_node->asgn = 0;
	  new_tree_node->parent = p_cur_tree_node;
          // check if it already has siblings
	  if(p_cur_tree_node->child == NULL){
            p_cur_tree_node->child = new_tree_node;
	    sib_ptrs[cur_c.row_idx] = new_tree_node;
          }
          else{
	    assert(sib_ptrs[cur_c.row_idx] != NULL);
	    sib_ptrs[cur_c.row_idx]->next_sibling = new_tree_node;
	    sib_ptrs[cur_c.row_idx] = new_tree_node;
	  }

	  //push the new cell_node in the BFS queue
	  _bfs.push(new_tree_node);
      //}//if
    //}//for
  }//while tmp_q

  return -1;  // did not form loop, countinue searching outside
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, 0x20(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x5683
movq %r14, 0x40(%rsp)
leaq 0x58(%rbx), %r15
leaq 0x88(%rbx), %r12
movsd 0x5b63(%rip), %xmm0     # 0xb0b0
movapd %xmm0, 0x10(%rsp)
xorl %r14d, %r14d
xorl %ebp, %ebp
movq 0x60(%rbx), %rcx
movq %r15, %rax
testq %rcx, %rcx
je 0x5581
movq %r15, %rax
movl 0x20(%rcx), %edx
xorl %esi, %esi
cmpq %rdx, %r14
cmovbeq %rcx, %rax
seta %sil
movq 0x10(%rcx,%rsi,8), %rcx
testq %rcx, %rcx
jne 0x5567
movq %r15, %rcx
cmpq %r15, %rax
je 0x5596
movl 0x20(%rax), %ecx
cmpq %rcx, %r14
cmovbq %r15, %rax
movq %rax, %rcx
cmpq %r15, %rcx
je 0x566e
movq 0xe0(%rbx), %rdi
movq %r14, %r13
shlq $0x5, %r13
movq (%rdi,%r13), %rax
cmpq 0x8(%rdi,%r13), %rax
sete %cl
je 0x566e
addq %r13, %rdi
movq 0x90(%rbx), %rsi
movq %r12, %rdx
testq %rsi, %rsi
je 0x55f0
movl (%rax), %r8d
movq %r12, %rdx
xorl %r9d, %r9d
cmpl %r8d, 0x20(%rsi)
setb %r9b
cmovaeq %rsi, %rdx
movq 0x10(%rsi,%r9,8), %rsi
testq %rsi, %rsi
jne 0x55d7
movq %r12, %rsi
cmpq %r12, %rdx
je 0x5604
movl (%rax), %esi
cmpl 0x20(%rdx), %esi
cmovbq %r12, %rdx
movq %rdx, %rsi
cmpq %r12, %rsi
je 0x5629
callq 0x70d8
movq 0xe0(%rbx), %rcx
leaq (%rcx,%r13), %rdi
movq (%rcx,%r13), %rax
cmpq 0x8(%rcx,%r13), %rax
sete %cl
jne 0x55c2
jmp 0x566e
testb $0x1, %cl
jne 0x566e
movsd 0x8(%rax), %xmm0
movl (%rax), %eax
movq 0x38(%rbx), %rcx
movq 0xf8(%rbx), %rdx
addsd (%rcx,%rax,8), %xmm0
movl (%rdx,%r14,4), %eax
subsd (%rcx,%rax,8), %xmm0
movapd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
movzbl %bpl, %ebp
movl $0x1, %eax
cmoval %eax, %ebp
minsd %xmm1, %xmm0
movapd %xmm0, 0x10(%rsp)
incq %r14
movl (%rbx), %eax
cmpq %rax, %r14
jb 0x5558
movq 0x40(%rsp), %r14
jmp 0x5693
movsd 0x5a25(%rip), %xmm0     # 0xb0b0
movapd %xmm0, 0x10(%rsp)
xorl %ebp, %ebp
xorpd %xmm0, %xmm0
leaq 0x50(%rsp), %rdi
movapd %xmm0, 0x40(%rdi)
movapd %xmm0, 0x30(%rdi)
movapd %xmm0, 0x20(%rdi)
movapd %xmm0, 0x10(%rdi)
movapd %xmm0, (%rdi)
xorl %esi, %esi
callq 0x84f4
testb $0x1, %bpl
je 0x5876
cmpl $0x0, (%rbx)
je 0x586e
leaq 0x58(%rbx), %rbp
leaq 0x88(%rbx), %r15
xorl %r13d, %r13d
movq 0x60(%rbx), %rcx
movq %rbp, %rax
testq %rcx, %rcx
je 0x5705
movq %rbp, %rax
movl 0x20(%rcx), %edx
xorl %esi, %esi
cmpq %rdx, %r13
cmovbeq %rcx, %rax
seta %sil
movq 0x10(%rcx,%rsi,8), %rcx
testq %rcx, %rcx
jne 0x56eb
movq %rbp, %rcx
cmpq %rbp, %rax
je 0x571a
movl 0x20(%rax), %ecx
cmpq %rcx, %r13
cmovbq %rbp, %rax
movq %rax, %rcx
cmpq %rbp, %rcx
je 0x5860
movq 0xe0(%rbx), %rdi
movq %r13, %r12
shlq $0x5, %r12
movq (%rdi,%r12), %rax
cmpq 0x8(%rdi,%r12), %rax
je 0x5860
addq %r12, %rdi
movq 0x90(%rbx), %rdx
movq %r15, %rcx
testq %rdx, %rdx
je 0x576f
movl (%rax), %esi
movq %r15, %rcx
xorl %r8d, %r8d
cmpl %esi, 0x20(%rdx)
setb %r8b
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%r8,8), %rdx
testq %rdx, %rdx
jne 0x5757
movq %r15, %rdx
cmpq %r15, %rcx
je 0x5783
movl (%rax), %edx
cmpl 0x20(%rcx), %edx
cmovbq %r15, %rcx
movq %rcx, %rdx
cmpq %r15, %rdx
je 0x5792
callq 0x70d8
jmp 0x5846
movsd 0x8(%rax), %xmm0
movl (%rax), %eax
movq 0x38(%rbx), %rcx
movq 0xf8(%rbx), %rdx
addsd (%rcx,%rax,8), %xmm0
movl (%rdx,%r13,4), %edx
subsd (%rcx,%rdx,8), %xmm0
subsd 0x10(%rsp), %xmm0
movapd %xmm0, %xmm2
andpd 0x590c(%rip), %xmm2     # 0xb0d0
movsd 0x58ec(%rip), %xmm1     # 0xb0b8
movapd %xmm2, 0x40(%rsp)
ucomisd %xmm2, %xmm1
jbe 0x580d
movl %r13d, 0x8(%rsp)
movl %eax, 0xc(%rsp)
movq 0x80(%rsp), %rax
movq 0x90(%rsp), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x5818
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
addq $0x8, 0x80(%rsp)
jmp 0x5827
ucomisd %xmm1, %xmm0
ja 0x5836
jmp 0x5c5d
leaq 0x50(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x866a
movq 0xe0(%rbx), %rdi
addq %r12, %rdi
callq 0x70d8
movsd 0x587a(%rip), %xmm0     # 0xb0b8
ucomisd 0x40(%rsp), %xmm0
jbe 0x5860
movq 0xe0(%rbx), %rcx
leaq (%rcx,%r12), %rdi
movq (%rcx,%r12), %rax
cmpq 0x8(%rcx,%r12), %rax
jne 0x5743
incq %r13
movl (%rbx), %eax
cmpq %rax, %r13
jb 0x56dc
movapd 0x10(%rsp), %xmm0
jmp 0x58b4
movl (%r14), %eax
movslq %eax, %rcx
movq 0x38(%rbx), %rdx
movq 0xc8(%rbx), %rsi
leaq (%rcx,%rcx,2), %rcx
movslq 0x4(%r14), %rdi
movq (%rsi,%rcx,8), %rcx
movsd (%rcx,%rdi,8), %xmm0
addsd (%rdx,%rdi,8), %xmm0
movq 0xf8(%rbx), %rcx
movl (%rcx,%rax,4), %eax
subsd (%rdx,%rax,8), %xmm0
xorpd 0x576c(%rip), %xmm0     # 0xb020
movq %xmm0, %rax
movq %rax, %rcx
btrq $0x3f, %rcx
movabsq $-0x10000000000000, %rdx # imm = 0xFFF0000000000000
addq %rcx, %rdx
shrq $0x35, %rdx
cmpl $0x3ff, %edx            # imm = 0x3FF
setae %cl
testq %rax, %rax
sets %dl
orb %cl, %dl
decq %rax
movabsq $0xffffffffffffe, %rcx  # imm = 0xFFFFFFFFFFFFE
cmpq %rcx, %rax
seta %al
testb %dl, %al
jne 0x5cbf
movl 0x4(%rbx), %eax
testq %rax, %rax
je 0x5979
movapd %xmm0, %xmm1
movq 0x38(%rbx), %rcx
movq 0x90(%rbx), %rdx
leaq 0x88(%rbx), %rsi
xorl %edi, %edi
movq %rsi, %r8
testq %rdx, %rdx
je 0x5948
movq %rdx, %r9
movq %rsi, %r8
movl 0x20(%r9), %r10d
xorl %r11d, %r11d
cmpq %r10, %rdi
cmovbeq %r9, %r8
seta %r11b
movq 0x10(%r9,%r11,8), %r9
testq %r9, %r9
jne 0x592c
movq %rsi, %r9
cmpq %rsi, %r8
je 0x595e
movl 0x20(%r8), %r9d
cmpq %r9, %rdi
cmovbq %rsi, %r8
movq %r8, %r9
cmpq %rsi, %r9
je 0x5971
movsd (%rcx,%rdi,8), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rcx,%rdi,8)
incq %rdi
cmpq %rax, %rdi
jne 0x591e
movl (%rbx), %esi
leaq 0x28(%rsp), %rdi
movq %rsp, %rdx
callq 0x7124
movl (%rbx), %ecx
testq %rcx, %rcx
je 0x5a15
movq 0x38(%rbx), %rax
movq 0xc8(%rbx), %rdx
movslq 0x4(%r14), %rsi
movq 0xf8(%rbx), %rdi
movq 0x28(%rsp), %r8
xorl %r9d, %r9d
movq (%rdx), %r10
movsd (%r10,%rsi,8), %xmm0
addsd (%rax,%rsi,8), %xmm0
movl (%rdi,%r9,4), %r10d
subsd (%rax,%r10,8), %xmm0
movsd %xmm0, (%r8,%r9,8)
incq %r9
addq $0x18, %rdx
cmpq %r9, %rcx
jne 0x59b1
movsd 0x56cd(%rip), %xmm0     # 0xb0b0
movq 0x28(%rsp), %rdx
xorl %esi, %esi
movl %ecx, %eax
movapd %xmm0, %xmm1
movsd (%rdx,%rsi,8), %xmm0
ucomisd %xmm0, %xmm1
cmoval %esi, %eax
minsd %xmm1, %xmm0
incq %rsi
cmpq %rsi, %rcx
jne 0x59ec
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
setb %dl
jmp 0x5a19
xorl %edx, %edx
movl %ecx, %eax
cmpl %ecx, %eax
je 0x5cde
testb %dl, %dl
je 0x5ad2
cmpl (%r14), %eax
je 0x5ae8
movq 0x60(%rbx), %rsi
leaq 0x58(%rbx), %rcx
movq %rcx, %rdx
testq %rsi, %rsi
je 0x5a5c
movq %rcx, %rdx
xorl %edi, %edi
cmpl %eax, 0x20(%rsi)
setb %dil
cmovaeq %rsi, %rdx
movq 0x10(%rsi,%rdi,8), %rsi
testq %rsi, %rsi
jne 0x5a45
movq %rcx, %rsi
cmpq %rcx, %rdx
je 0x5a6e
cmpl 0x20(%rdx), %eax
cmovbq %rcx, %rdx
movq %rdx, %rsi
cmpq %rcx, %rsi
je 0x5ae8
movl %eax, (%r14)
movl %eax, %eax
movq 0x128(%rbx), %rcx
movq (%rcx,%rax,8), %r15
testq %r15, %r15
je 0x5cfd
movq %r14, %r12
leaq 0x110(%rbx), %r14
movq %r14, %rdi
callq 0x709c
cmpl $-0x1, 0x8(%r15)
je 0x5bff
movl $0x18, %edi
callq 0x3250
movq (%r15), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x3040
incq 0x120(%rbx)
movq 0x18(%r15), %r15
jmp 0x5a9e
addq $0x110, %rbx            # imm = 0x110
movq %rbx, %rdi
callq 0x709c
xorl %ebp, %ebp
jmp 0x5c28
movq 0x60(%rsp), %rax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpq %rax, 0x80(%rsp)
je 0x5c28
movl (%rax), %r14d
movl 0x4(%rax), %r12d
movq 0x70(%rsp), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x5b1b
addq $0x8, %rax
jmp 0x5b4d
movq 0x68(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x3260
movq 0x78(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x78(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x68(%rsp)
leaq 0x200(%rax), %rcx
movq %rcx, 0x70(%rsp)
movslq %r14d, %r13
movq %rax, 0x60(%rsp)
movq 0x128(%rbx), %rax
movq (%rax,%r13,8), %r15
movl $0x28, %edi
callq 0x3250
xorpd %xmm0, %xmm0
movupd %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movq %rax, (%rsp)
movl %r14d, (%rax)
movl %r12d, 0x4(%rax)
movl $0x0, 0x8(%rax)
movq %r15, 0x18(%rax)
cmpq $0x0, 0x10(%r15)
je 0x5bb6
movq 0x140(%rbx), %rdx
movq (%rdx,%r13,8), %rcx
testq %rcx, %rcx
je 0x5ca0
leaq (%rdx,%r13,8), %r13
movq %rax, 0x20(%rcx)
jmp 0x5bc5
movq %rax, 0x10(%r15)
shlq $0x3, %r13
addq 0x140(%rbx), %r13
movq 0x20(%rsp), %rdi
movq %rax, (%r13)
movq 0x30(%rdi), %rax
movq 0x40(%rdi), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x5bed
movq (%rsp), %rcx
movq %rcx, (%rax)
addq $0x8, 0x30(%rdi)
jmp 0x5bf5
movq %rsp, %rsi
callq 0x8190
movq 0x60(%rsp), %rax
jmp 0x5af2
movl $0x18, %edi
callq 0x3250
movq (%r12), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x3040
incq 0x120(%rbx)
movl $0x1, %ebp
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x5c3f
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x3260
leaq 0x50(%rsp), %rdi
callq 0x7422
movl %ebp, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x938c(%rip), %rdi      # 0xeff0
leaq 0x5578(%rip), %rsi      # 0xb1e3
movl $0x1a, %edx
callq 0x32a0
movq 0x9374(%rip), %rdi      # 0xeff0
callq 0x3110
leaq 0x5635(%rip), %rdi      # 0xb2bd
leaq 0x5468(%rip), %rsi      # 0xb0f7
leaq 0x5568(%rip), %rcx      # 0xb1fe
movl $0x201, %edx            # imm = 0x201
callq 0x3150
leaq 0x54f8(%rip), %rdi      # 0xb19f
leaq 0x5449(%rip), %rsi      # 0xb0f7
leaq 0x5549(%rip), %rcx      # 0xb1fe
movl $0x285, %edx            # imm = 0x285
callq 0x3150
leaq 0x556e(%rip), %rdi      # 0xb234
leaq 0x542a(%rip), %rsi      # 0xb0f7
leaq 0x552a(%rip), %rcx      # 0xb1fe
movl $0x22e, %edx            # imm = 0x22E
callq 0x3150
leaq 0x5590(%rip), %rdi      # 0xb275
leaq 0x540b(%rip), %rsi      # 0xb0f7
leaq 0x550b(%rip), %rcx      # 0xb1fe
movl $0x24a, %edx            # imm = 0x24A
callq 0x3150
leaq 0x558b(%rip), %rdi      # 0xb28f
leaq 0x53ec(%rip), %rsi      # 0xb0f7
leaq 0x54ec(%rip), %rcx      # 0xb1fe
movl $0x25a, %edx            # imm = 0x25A
callq 0x3150
jmp 0x5d22
jmp 0x5d42
jmp 0x5d22
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x5d45
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x3260
jmp 0x5d45
jmp 0x5d42
jmp 0x5d42
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x7422
movq %rbx, %rdi
callq 0x33d0
nop