LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/MPSLab-ASU[P]DiRAC/./src/pe.cc
// Function: PE::~PE()
PE::~PE()
{
  for(uint8_t i=0; i < inNetworks; i++)
    delete buf_in[i];
  for(uint8_t i=0; i < outNetworks; i++)
    delete buf_out[i];
  delete[] buf_in;
  delete[] buf_out;

  delete[] in_config;
  delete[] in_forward;
  delete[] in_data;

  delete[] write_back;
  delete[] out_data;

  delete[] RegFile;

  delete[] state_multiplier_stages;
  delete[] state_adder_stages;
  delete[] temp_reg_multiply;
  delete[] temp_reg_add_Op1;
  delete[] temp_reg_add_Op2;
  delete[] temp_reg_idx_write_Op3;
  delete[] temp_sel_sig_adder_is_Op2_self;
  delete[] temp_sel_sig_adder_Op2_zero_initialize_current_RF_Pass;

  delete[] insMem;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x1ecca1(%rip), %rax    # 0x5fe9f0
movq %rax, (%rdi)
xorl %r12d, %r12d
movq $0x606151, %r13         # imm = 0x606151
pushq $0x10
popq %r14
movzbl (%r13), %eax
cmpq %rax, %r12
jae 0x411d8f
movq 0x48(%rbx), %rax
movq (%rax,%r12,8), %r15
testq %r15, %r15
je 0x411d7f
movq %r15, %rdi
callq 0x41292e
movq %r15, %rdi
movq %r14, %rsi
callq 0x412c50
incq %r12
jmp 0x411d60
xorl %r12d, %r12d
movq $0x6085e4, %r13         # imm = 0x6085E4
pushq $0x10
popq %r14
movzbl (%r13), %eax
cmpq %rax, %r12
jae 0x411dcc
movq 0x50(%rbx), %rax
movq (%rax,%r12,8), %r15
testq %r15, %r15
je 0x411dbc
movq %r15, %rdi
callq 0x41292e
movq %r15, %rdi
movq %r14, %rsi
callq 0x412c50
incq %r12
jmp 0x411d9d
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x411dda
callq 0x412c60
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x411de8
callq 0x412c60
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x411df6
callq 0x412c60
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x411e04
callq 0x412c60
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x411e12
callq 0x412c60
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x411e20
callq 0x412c60
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x411e2e
callq 0x412c60
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x411e3c
callq 0x412c60
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x411e4d
callq 0x412c60
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x411e5e
callq 0x412c60
movq 0x108(%rbx), %rdi
testq %rdi, %rdi
je 0x411e6f
callq 0x412c60
movq 0x110(%rbx), %rdi
testq %rdi, %rdi
je 0x411e80
callq 0x412c60
movq 0x118(%rbx), %rdi
testq %rdi, %rdi
je 0x411e91
callq 0x412c60
movq 0x120(%rbx), %rdi
testq %rdi, %rdi
je 0x411ea2
callq 0x412c60
movq 0x140(%rbx), %rdi
testq %rdi, %rdi
je 0x411eb3
callq 0x412c60
movq 0x130(%rbx), %rdi
testq %rdi, %rdi
je 0x411ec4
callq 0x412c60
movq 0xe8(%rbx), %rdi
testq %rdi, %rdi
je 0x411ede
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x412c60
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/MPSLab-ASU[P]DiRAC/./src/pe.cc
// Function: PE::readBuffers()
void PE::readBuffers()
{
  if(!(buf_in[0]->isEmpty()))
  {
    data_type temp = buf_in[0]->pop();
    write_RF(buf_to_reg_idx_Op1, temp);
    buf_to_reg_idx_Op1++;
  }
  if(!(buf_in[1]->isEmpty()))
  {
    data_type temp = buf_in[1]->pop();
    write_RF(buf_to_reg_idx_Op2, temp);
    buf_to_reg_idx_Op2++;
  }
  if(inNetworks > 2)
  {
    if(!(buf_in[2]->isEmpty()))
    {
      data_type temp = buf_in[2]->pop();
      write_RF(buf_to_reg_idx_Op3, temp);
      buf_to_reg_idx_Op3++;
    }
  }
}

// Assembly:
movq 0x48(%rdi), %rcx
movq (%rcx), %rsi
movzbl 0x8(%rsi), %eax
cmpb 0x9(%rsi), %al
je 0x412009
movq (%rsi), %rdx
movzwl (%rdx,%rax,2), %r8d
incl %eax
movq $0x606156, %rdx         # imm = 0x606156
movzbl (%rdx), %r9d
xorl %edx, %edx
divw %r9w
movb %dl, 0x8(%rsi)
movzwl 0x26(%rdi), %eax
movq 0x18(%rdi), %rdx
movw %r8w, (%rdx,%rax,2)
incw 0x26(%rdi)
movq 0x8(%rcx), %rsi
movzbl 0x8(%rsi), %eax
cmpb 0x9(%rsi), %al
je 0x412045
movq (%rsi), %rdx
movzwl (%rdx,%rax,2), %r8d
incl %eax
movq $0x606156, %rdx         # imm = 0x606156
movzbl (%rdx), %r9d
xorl %edx, %edx
divw %r9w
movb %dl, 0x8(%rsi)
movzwl 0x28(%rdi), %eax
movq 0x18(%rdi), %rdx
movw %r8w, (%rdx,%rax,2)
incw 0x28(%rdi)
movq $0x606151, %rax         # imm = 0x606151
cmpb $0x3, (%rax)
jb 0x41208b
movq 0x10(%rcx), %rcx
movzbl 0x8(%rcx), %eax
cmpb 0x9(%rcx), %al
je 0x41208b
movq (%rcx), %rdx
movzwl (%rdx,%rax,2), %esi
incl %eax
movq $0x606156, %rdx         # imm = 0x606156
movzbl (%rdx), %r8d
xorl %edx, %edx
divw %r8w
movb %dl, 0x8(%rcx)
movzwl 0x2a(%rdi), %eax
movq 0x18(%rdi), %rcx
movw %si, (%rcx,%rax,2)
incw 0x2a(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/MPSLab-ASU[P]DiRAC/./src/pe.cc
// Function: PE::writeBuffers()
void PE::writeBuffers()
{
  for(uint8_t i=0; i < outNetworks; i++)
  {
    if(sig_write_back_current_RF_Pass && (counter_PE_WB >= delay_PE_WB_reduce))
    {
      if(counter_writeback_Op1 < cnt_output_Op1)
      {
        data_type temp = read_RF(reg_to_buf_idx_Op1);
        buf_out[i]->push(temp);
        // ToDO: Generalize following variables and counters to work with
        // i output networks; i > 1.
        reg_to_buf_idx_Op1++;
        counter_writeback_Op1++;
      }
    }
    else
      counter_PE_WB += 1;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movb 0x138(%rdi), %cl
movq 0x18(%rdi), %rsi
movq 0x50(%rdi), %r8
movq $0x6085e4, %r9          # imm = 0x6085E4
movb (%r9), %al
movq $0x606150, %r10         # imm = 0x606150
movq $0x606156, %r11         # imm = 0x606156
xorl %ebx, %ebx
movzbl %al, %edx
cmpq %rdx, %rbx
jae 0x41212a
movzwl 0x38(%rdi), %edx
testb $0x1, %cl
je 0x41211f
movzbl (%r10), %ebp
cmpw %bp, %dx
jb 0x41211f
movzwl 0x36(%rdi), %edx
cmpw 0x34(%rdi), %dx
jae 0x412125
movzwl 0x2c(%rdi), %eax
movzwl (%rsi,%rax,2), %edx
movq (%r8,%rbx,8), %r14
movq (%r14), %r15
movzbl 0x9(%r14), %eax
movw %dx, (%r15,%rax,2)
incl %eax
movzbl (%r11), %ebp
xorl %edx, %edx
divw %bp
movb %dl, 0x9(%r14)
incw 0x2c(%rdi)
incw 0x36(%rdi)
movb (%r9), %al
jmp 0x412125
incl %edx
movw %dx, 0x38(%rdi)
incq %rbx
jmp 0x4120c6
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/MPSLab-ASU[P]DiRAC/./src/pe.cc
// Function: PE::execute_out_buf_read()
void PE::execute_out_buf_read()
{
  for(uint8_t i=0; i < outNetworks; i++)
  {
    if(!buf_out[i]->isEmpty())
    {
      (out_data[i]) = buf_out[i]->pop();
      (write_back[i]) = true;
    }
    else
    {
      (write_back[i]) = false;
      (out_data[i]) = 0;
    }
  }
}

// Assembly:
pushq %rbp
pushq %rbx
movq 0x50(%rdi), %rcx
movq 0x70(%rdi), %rsi
movq 0x78(%rdi), %rdi
movq $0x6085e4, %r8          # imm = 0x6085E4
movq $0x606156, %r9          # imm = 0x606156
xorl %r10d, %r10d
movzbl (%r8), %eax
cmpq %rax, %r10
jae 0x4121e2
movq (%rcx,%r10,8), %rbx
movzbl 0x8(%rbx), %eax
cmpb 0x9(%rbx), %al
jne 0x4121bc
xorl %eax, %eax
xorl %r11d, %r11d
jmp 0x4121d4
movq (%rbx), %rdx
movzwl (%rdx,%rax,2), %r11d
incl %eax
movzbl (%r9), %ebp
xorl %edx, %edx
divw %bp
movb %dl, 0x8(%rbx)
movb $0x1, %al
movb %al, (%rsi,%r10)
movw %r11w, (%rdi,%r10,2)
incq %r10
jmp 0x41219f
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/MPSLab-ASU[P]DiRAC/./src/pe.cc
// Function: PE::execute_pipeline()
void PE::execute_pipeline()
{
  // write buffer
  if(state_write_RF == true)
    writeOutputReg();

  compute();

  if(state_read_RF == true)
    readInputRegs();

  if(state_decode == true)
    decode(fetched_instn);

  // Execution events to occur when PE is in execution mode.
  if(state_fetch == true)
    fetched_instn = insMem[counter_PE_exec];

  update_FFs();
  update_pipeline_states();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x98(%rdi)
jne 0x412221
movq $0x606154, %rax         # imm = 0x606154
movzbl (%rax), %eax
movq $0x606155, %rcx         # imm = 0x606155
movzbl (%rcx), %ecx
addq %rax, %rax
addq 0x120(%rbx), %rax
movzwl (%rax,%rcx,2), %eax
movzwl 0x42(%rbx), %ecx
movq 0x18(%rbx), %rdx
movw %cx, (%rdx,%rax,2)
movq %rbx, %rdi
callq 0x412622
cmpb $0x1, 0x82(%rbx)
jne 0x41223a
movq %rbx, %rdi
callq 0x412634
cmpb $0x1, 0x81(%rbx)
jne 0x412252
movq 0xf0(%rbx), %rsi
movq %rbx, %rdi
callq 0x41265e
cmpb $0x1, 0x80(%rbx)
jne 0x412274
movq 0xe8(%rbx), %rax
movzwl 0x9c(%rbx), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0xf0(%rbx)
movq 0x130(%rbx), %rax
movzwl (%rax), %ecx
movw %cx, 0x1(%rax)
movb 0x128(%rbx), %cl
movb %cl, (%rax)
movq %rbx, %rdi
popq %rbx
jmp 0x412726
nop
// File: /workspace/github_cpp_makefile_star2_O2/MPSLab-ASU[P]DiRAC/./src/pe.cc
// Function: PE::update_trigger_states()
void PE::update_trigger_states()
{
  if(PE_Next_State == execute)
  {
    PE_State = execute;
    state_fetch = true;
    PE_Next_State = idle;
  }

  sel_sig_adder_Op2_zero_initialize_current_RF_Pass = PE_zero_initialize_next_pass;
  PE_zero_initialize_next_pass = false;

  if(sig_update_buffer_num_Op1_next_pass)
  {
    buffer_number_comp_op[0] = (buffer_number_comp_op[0] + 1) % 2;
    buffer_number_comm_op[0] = (buffer_number_comm_op[0] + 1) % 2;
    sig_update_buffer_num_Op1_next_pass = false;
  }
  if(sig_update_buffer_num_Op2_next_pass)
  {
    buffer_number_comp_op[1] = (buffer_number_comp_op[1] + 1) % 2;
    buffer_number_comm_op[1] = (buffer_number_comm_op[1] + 1) % 2;
    sig_update_buffer_num_Op2_next_pass = false;
  }
  if(sig_update_buffer_num_Op3_next_pass)
  {
    buffer_number_comp_op[2] = (buffer_number_comp_op[2] + 1) % 2;
    buffer_number_comm_op[2] = (buffer_number_comm_op[2] + 1) % 2;
    sig_update_buffer_num_Op3_next_pass = false;
  }
}

// Assembly:
cmpl $0x1, 0xc(%rdi)
jne 0x412481
movq $0x1, 0x8(%rdi)
movb $0x1, 0x80(%rdi)
movb 0xd9(%rdi), %al
movb 0xdb(%rdi), %cl
movb %al, 0x128(%rdi)
movb $0x0, 0xd9(%rdi)
cmpb $0x1, %cl
jne 0x4124c7
movb 0xde(%rdi), %al
movb 0xe1(%rdi), %cl
notb %cl
andb $0x1, %cl
movb %cl, 0xe1(%rdi)
notb %al
andb $0x1, %al
movb %al, 0xde(%rdi)
movb $0x0, 0xdb(%rdi)
cmpb $0x1, 0xdc(%rdi)
jne 0x4124f8
movb 0xdf(%rdi), %al
movb 0xe2(%rdi), %cl
notb %cl
andb $0x1, %cl
movb %cl, 0xe2(%rdi)
notb %al
andb $0x1, %al
movb %al, 0xdf(%rdi)
movb $0x0, 0xdc(%rdi)
cmpb $0x1, 0xdd(%rdi)
jne 0x412529
movb 0xe0(%rdi), %al
movb 0xe3(%rdi), %cl
notb %cl
andb $0x1, %cl
movb %cl, 0xe3(%rdi)
notb %al
andb $0x1, %al
movb %al, 0xe0(%rdi)
movb $0x0, 0xdd(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/MPSLab-ASU[P]DiRAC/./src/pe.cc
// Function: PE::decode(unsigned long)
void PE::decode(uint64_t ins)
{
  // Update FlipFlops for copying signal for mux in last stage of adder,
  // which decides to select operand2 for addition, selected between
  // propagated value vs. self (data from the output latch of adder).
  for(uint8_t it=multiplier_stages+adder_stages-1; it>0; it--)
    temp_sel_sig_adder_is_Op2_self[it] = temp_sel_sig_adder_is_Op2_self[it-1];
  temp_sel_sig_adder_is_Op2_self[0] = sel_sig_adder_is_Op2_self;

  // Update FlipFlops for copying idx for writing back to same reg as read for Op3
  for(uint8_t it=multiplier_stages+adder_stages; it>0; it--)
    temp_reg_idx_write_Op3[it] = temp_reg_idx_write_Op3[it-1];
  temp_reg_idx_write_Op3[0] = reg_read_Op3;

  sel_sig_adder_is_Op2_self = (ins & 0x01);

  reg_read_Op3 = reg_idx_Op3_comp + ((ins >> 8) & 0xFF);
  reg_read_Op2 = reg_idx_Op2_comp + ((ins >> 16) & 0xFF);
  reg_read_Op1 = reg_idx_Op1_comp + ((ins >> 24) & 0xFF);
}

// Assembly:
movq %rsi, %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq $0x606154, %rdx         # imm = 0x606154
movb (%rdx), %r9b
movq $0x606155, %rsi         # imm = 0x606155
movq 0x140(%rdi), %r8
addb (%rsi), %r9b
decb %r9b
movzbl %r9b, %r9d
testb %r9b, %r9b
je 0x41269e
leal (%r9,%rcx), %r10d
movb (%r8,%r10), %r10b
movb %r10b, (%r8,%r9)
decq %r9
jmp 0x412688
movb 0x139(%rdi), %r9b
movb %r9b, (%r8)
movb (%rsi), %sil
addb (%rdx), %sil
movq 0x120(%rdi), %rdx
movzbl %sil, %esi
movq %rsi, %r8
subq $0x1, %r8
jb 0x4126d5
leal (%rsi,%rcx), %r9d
movzwl (%rdx,%r9,2), %r9d
movw %r9w, (%rdx,%rsi,2)
movq %r8, %rsi
jmp 0x4126bc
movzwl 0x24(%rdi), %ecx
movw %cx, (%rdx)
movl %eax, %ecx
andb $0x1, %cl
movb %cl, 0x139(%rdi)
movzbl %ah, %ecx
addw 0x32(%rdi), %cx
movw %cx, 0x24(%rdi)
movl %eax, %ecx
shrl $0x10, %ecx
movzbl %cl, %ecx
addw 0x30(%rdi), %cx
movw %cx, 0x22(%rdi)
shrl $0x18, %eax
addw 0x2e(%rdi), %ax
movw %ax, 0x20(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/MPSLab-ASU[P]DiRAC/./src/pe.cc
// Function: PE::update_pipeline_states()
void PE::update_pipeline_states()
{
  state_write_RF = state_adder_stages[adder_stages-1];

  // Do not need following code when we have actual x-stage adder
  for(uint8_t it=adder_stages-1; it>0; it--)
    state_adder_stages[it] =  state_adder_stages[it-1];
  state_adder_stages[0] = state_multiplier_stages[multiplier_stages-1];

  // Do not need following code when we have actual x-stage multiplier
  for(uint8_t it=multiplier_stages-1; it>0; it--)
    state_multiplier_stages[it] =  state_multiplier_stages[it-1];
  state_multiplier_stages[0] = state_read_RF;

  state_read_RF = state_decode;
  state_decode = state_fetch;
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq 0x90(%rdi), %rcx
movq $0x606155, %rdx         # imm = 0x606155
movzbl (%rdx), %edx
movb -0x1(%rcx,%rdx), %sil
movb %sil, 0x98(%rdi)
leal -0x1(%rdx), %esi
movl %esi, %edx
subb $0x1, %dl
jb 0x412766
movzbl %sil, %esi
leal (%rax,%rsi), %r8d
movb (%rcx,%r8), %r8b
movb %r8b, (%rcx,%rsi)
movl %edx, %esi
jmp 0x41274d
movq 0x88(%rdi), %rdx
movq $0x606154, %rsi         # imm = 0x606154
movzbl (%rsi), %r8d
movb -0x1(%rdx,%r8), %r8b
movb %r8b, (%rcx)
movb (%rsi), %cl
decb %cl
movzbl %cl, %ecx
testb %cl, %cl
je 0x41279b
leal (%rcx,%rax), %esi
movb (%rdx,%rsi), %sil
movb %sil, (%rdx,%rcx)
decq %rcx
jmp 0x412787
movb 0x82(%rdi), %al
movb %al, (%rdx)
movzwl 0x80(%rdi), %eax
movw %ax, 0x81(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/MPSLab-ASU[P]DiRAC/./src/pe.cc
// Function: PE::compute_multiplication()
void PE::compute_multiplication()
{
  // Do not need following code for temp_reg when we have actual x-stage multiplier
  for(uint8_t it=multiplier_stages-1; it>0; it--)
  {
      temp_reg_multiply[it] = temp_reg_multiply[it-1];
  }

  temp_reg_add_Op1[0] = temp_reg_multiply[multiplier_stages-1];

  // Do not need following condition when we have actual x-stage multiplier
  if(state_multiplier_stages[0])
  {
    temp_reg_multiply[0] = (in1 * in2);
  }
}

// Assembly:
movq $0x606154, %rcx         # imm = 0x606154
movb (%rcx), %dl
movq 0x108(%rdi), %rax
decb %dl
movzbl %dl, %edx
testb %dl, %dl
je 0x4127db
leal -0x1(%rdx), %esi
movzwl (%rax,%rsi,2), %esi
movw %si, (%rax,%rdx,2)
decq %rdx
jmp 0x4127c7
movzbl (%rcx), %ecx
movzwl -0x2(%rax,%rcx,2), %ecx
movq 0x110(%rdi), %rdx
movw %cx, (%rdx)
movq 0x88(%rdi), %rcx
cmpb $0x0, (%rcx)
je 0x412805
movzwl 0x3c(%rdi), %ecx
imulw 0x3a(%rdi), %cx
movw %cx, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/MPSLab-ASU[P]DiRAC/./src/pe.cc
// Function: PE::compute_addition()
void PE::compute_addition()
{
  data_type add_Op1;
  data_type add_Op2;

  add_Op1 = temp_reg_add_Op1[adder_stages-1];

  if(temp_sel_sig_adder_is_Op2_self[multiplier_stages+adder_stages-1] == false) // (zero_initialize_Op_current_RF_Pass)
  // case 0:
  {
    add_Op2 = out_MAC;
  }
  else  // case 1:
  {
    add_Op2 = temp_reg_add_Op2[(multiplier_stages+adder_stages-1) - 1];
  }

  if(state_adder_stages[adder_stages-1])
    out_MAC = add_Op1 + add_Op2;

  // Update FFs for propagating input Operand2 for adder
  for(auto it1=(multiplier_stages+adder_stages-1) - 1; it1>0; it1--)
    temp_reg_add_Op2[it1] = temp_reg_add_Op2[it1-1];

  // pipelined in parallel with first stage of multiplier
  if(temp_sel_sig_adder_Op2_zero_initialize_current_RF_Pass[2] == 0)
  // case 0:
    temp_reg_add_Op2[0] = in3;
  else  // case 1:
    temp_reg_add_Op2[0] = 0;

  // Update FFs for propagating input Operand1 for adder
  for(auto it1=adder_stages-1; it1>0; it1--)
    temp_reg_add_Op1[it1] = temp_reg_add_Op1[it1-1];
}

// Assembly:
movq 0x90(%rdi), %r9
movq 0x110(%rdi), %rax
movq $0x606155, %rcx         # imm = 0x606155
movzbl (%rcx), %r8d
movq $0x606154, %rdx         # imm = 0x606154
movzbl (%rdx), %esi
addq %r8, %rsi
movq 0x118(%rdi), %rdx
cmpb $0x1, -0x1(%r9,%r8)
jne 0x412864
movq 0x140(%rdi), %r9
cmpb $0x0, -0x1(%r9,%rsi)
leaq 0x42(%rdi), %r9
leaq -0x4(%rdx,%rsi,2), %r10
cmoveq %r9, %r10
movzwl (%r10), %r9d
addw -0x2(%rax,%r8,2), %r9w
movw %r9w, 0x42(%rdi)
addl $-0x2, %esi
testl %esi, %esi
jle 0x41287b
movzwl -0x2(%rdx,%rsi,2), %r8d
movw %r8w, (%rdx,%rsi,2)
decq %rsi
jmp 0x412867
movq 0x130(%rdi), %rsi
cmpb $0x0, 0x2(%rsi)
jne 0x41288e
movzwl 0x3e(%rdi), %esi
jmp 0x412890
xorl %esi, %esi
movw %si, (%rdx)
movzbl (%rcx), %ecx
cmpq $0x1, %rcx
jle 0x4128ab
movzwl -0x4(%rax,%rcx,2), %edx
movw %dx, -0x2(%rax,%rcx,2)
decq %rcx
jmp 0x412896
retq
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/main.cpp
// Function: countcommas(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int countcommas(string x){
        string s = x;
        int commas=0;
        for(int i=0; i<s.length();i++){
            if(s[i]==','){
                commas++;
            }

        }
        return commas;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rsi
leaq -0x28(%rbp), %rbx
movq %rbx, %rdi
callq 0x3410
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
xorl %edx, %edx
xorl %ebx, %ebx
cmpq %rdx, %rcx
je 0x3845
xorl %esi, %esi
cmpb $0x2c, (%rax,%rdx)
sete %sil
addl %esi, %ebx
incq %rdx
jmp 0x382f
leaq -0x28(%rbp), %rdi
callq 0x3170
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/main.cpp
// Function: addcomma(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void addcomma(string& z){
    for(int j=0; j<z.length()-1;j++){
        if(z[j]==']'){
            int open=z.find_first_of('[',j);
            string str=z.substr(j+1,open-j-1);
            if(str.find_first_not_of(' ') != std::string::npos){

            }
            else{
                z.replace(j,1,"],");
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %r13d, %r13d
leaq -0x48(%rbp), %r15
pushq $0x20
popq %r12
movq 0x8(%rbx), %rax
decq %rax
cmpq %r13, %rax
jbe 0x38f0
movq (%rbx), %rax
cmpb $0x5d, (%rax,%r13)
jne 0x38eb
movq %rbx, %rdi
pushq $0x5b
popq %rsi
movq %r13, %rdx
callq 0x33e0
leaq 0x1(%r13), %r14
movl %r13d, %ecx
notl %ecx
addl %ecx, %eax
movslq %eax, %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3360
movq %r15, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x32f0
cmpq $-0x1, %rax
jne 0x38de
movq %rbx, %rdi
movq %r13, %rsi
pushq $0x1
popq %rdx
leaq 0xb793(%rip), %rcx      # 0xf06c
callq 0x3240
movq %r15, %rdi
callq 0x3170
movq %r14, %r13
jmp 0x3876
incq %r13
jmp 0x3876
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/main.cpp
// Function: isChar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool isChar(string s)
{
	//if (s.size() >1) return false;

	switch (s[0]) {
	case '+': return true;
	case '-': return true;
	case '*': return true;
	case '/': return true;
	case '(': return true;
	case ')': return true;
	case '^': return true;
	case '.': if(s[1]=='+') return true;
	else if(s[1]=='-') return true;
    else if(s[1]=='*') return true;
    else if(s[1]=='/') return true;
    else if(s[1]=='^') return true;
	default: return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rcx
movzbl (%rcx), %edx
addl $-0x28, %edx
cmpl $0x36, %edx
ja 0x622c
movb $0x1, %al
movabsq $0x400000000000af, %rsi # imm = 0x400000000000AF
btq %rdx, %rsi
jae 0x620c
andb $0x1, %al
popq %rbp
retq
cmpq $0x6, %rdx
jne 0x622c
movb 0x1(%rcx), %cl
addb $-0x2a, %cl
cmpb $0x35, %cl
jae 0x622c
movabsq $0x1000000000002b, %rax # imm = 0x1000000000002B
shrq %cl, %rax
jmp 0x6208
xorl %eax, %eax
jmp 0x6208
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/main.cpp
// Function: preference(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int preference(string ch)
{
	switch (ch[0])
	{
	case '+': return 1;
	case '-': return 1;
	case '*': return 2;
	case '/': return 2;
	case '^': return 3;
	case '(': return -1;
	case '.': if(ch[1]=='+') return 1;
	else if(ch[1]=='-') return 1;
    else if(ch[1]=='*') return 2;
    else if(ch[1]=='/') return 2;
    else if(ch[1]=='^') return 3;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movzbl (%rax), %ecx
addl $-0x28, %ecx
cmpl $0x7, %ecx
ja 0x6665
leaq 0x89e6(%rip), %rdx      # 0xf034
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl $0x1, %eax
jmp 0x669a
movl $0x2, %eax
jmp 0x669a
movl $0x3, %eax
jmp 0x669a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x669a
movb 0x1(%rax), %cl
addb $-0x2a, %cl
movl $0x3, %eax
cmpb $0x6, %cl
jae 0x669a
movzbl %cl, %ecx
movl $0x2b, %edx
btl %ecx, %edx
jae 0x669a
leaq 0x89bd(%rip), %rax      # 0xf054
movl (%rax,%rcx,4), %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::Matrix()
Matrix::Matrix() //default constructor
{
	nRows = nColumns = 0;
	values = NULL;
	cvalues=NULL;
	type="none";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x28(%rdi), %rax
movq %rax, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
leaq 0x18(%rdi), %rbx
movb $0x0, 0x28(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x67ec(%rip), %rsi      # 0xf1f0
movq %rbx, %rdi
callq 0x35a0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3170
movq %r14, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::reset()
void Matrix::reset()
{   if(type=="complex")
   {
    if(cvalues)
    {
      for(int i=0;i<nRows;i++)
        delete[] cvalues[i];
    }
		delete[] cvalues;
   }
    else
    {
	if (values)
		for (int i = 0;i<nRows;i++)
			delete[] values[i];
        delete[] values;
    }
	nRows = nColumns = 0;
	values = NULL;
	cvalues=NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
addq $0x18, %rdi
leaq 0x679c(%rip), %rsi      # 0xf1f5
callq 0x795a
testb %al, %al
je 0x8a8b
cmpq $0x0, 0x10(%rbx)
je 0x8abe
xorl %r14d, %r14d
movslq (%rbx), %rax
movq 0x10(%rbx), %rdi
cmpq %rax, %r14
jge 0x8ab4
movq (%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x8a86
callq 0x33c0
incq %r14
jmp 0x8a6c
cmpq $0x0, 0x8(%rbx)
je 0x8abe
xorl %r14d, %r14d
movslq (%rbx), %rax
movq 0x8(%rbx), %rdi
cmpq %rax, %r14
jge 0x8ab4
movq (%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x8aaf
callq 0x33c0
incq %r14
jmp 0x8a95
testq %rdi, %rdi
je 0x8abe
callq 0x33c0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::Matrix(int, int, int, double)
Matrix::Matrix(int nRows, int nColumns, int initialization, double initializationValue)
{
	this->nRows = nRows;
	this->nColumns = nColumns;
	cvalues=NULL;
	if ((nRows*nColumns) == 0)
	{
		values = NULL;
		return;
	}
	values = new double*[nRows];
	for (int iR = 0;iR<nRows;iR++)
	{
		values[iR] = new double[nColumns];
		for (int iC = 0;iC<nColumns;iC++)
		{
			switch (initialization)
			{
			case MI_ZEROS:
				values[iR][iC] = 0;
				break;
			case MI_ONES:
				values[iR][iC] = 1;
				break;
			case MI_EYE:
				values[iR][iC] = (iR == iC) ? 1 : 0;
				break;
			case MI_RAND: values[iR][iC] = (rand() % 1000000) / 1000000.0;
				break;
			case MI_VALUE:
				values[iR][iC] = initializationValue;
				break;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, -0x48(%rbp)
movq %rdi, %r12
leaq 0x28(%rdi), %rax
movq %rax, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
andq $0x0, 0x10(%rdi)
movl %ecx, -0x2c(%rbp)
movl %edx, %eax
imull %esi, %eax
testl %eax, %eax
je 0x8c04
movq %rdx, %r14
movl %esi, %edi
shlq $0x3, %rdi
movq %rsi, %rbx
testl %esi, %esi
pushq $-0x1
popq %r13
cmovsq %r13, %rdi
callq 0x3030
movq %rax, 0x8(%r12)
movl %r14d, %eax
shlq $0x3, %rax
xorl %r15d, %r15d
testl %r14d, %r14d
cmovsq %r13, %rax
movq %rax, -0x40(%rbp)
cmovlel %r15d, %r14d
movq %r14, %r13
movq %rbx, %rcx
testl %ecx, %ecx
cmovlel %r15d, %ecx
movl -0x2c(%rbp), %eax
movq %rax, -0x50(%rbp)
leaq 0x662b(%rip), %rbx      # 0xf190
movq %rcx, %rax
movq %rcx, -0x38(%rbp)
cmpq %rax, %r15
je 0x8c0a
movq -0x40(%rbp), %rdi
callq 0x3030
movq %r12, %r14
movq 0x8(%r12), %rcx
movq %rax, (%rcx,%r15,8)
xorl %r12d, %r12d
cmpq %r12, %r13
je 0x8bf5
cmpl $0x4, -0x2c(%rbp)
ja 0x8bf0
movq -0x50(%rbp), %rax
movslq (%rbx,%rax,4), %rax
addq %rbx, %rax
jmpq *%rax
movsd 0x65ab(%rip), %xmm0     # 0xf158
jmp 0x8be2
movsd -0x48(%rbp), %xmm0
jmp 0x8be2
movsd 0x659a(%rip), %xmm0     # 0xf158
cmpq %r12, %r15
je 0x8be2
xorpd %xmm0, %xmm0
jmp 0x8be2
callq 0x30d0
cltd
movl $0xf4240, %ecx          # imm = 0xF4240
idivl %ecx
cvtsi2sd %edx, %xmm0
divsd 0x656e(%rip), %xmm0     # 0xf150
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
jmp 0x8b8d
incq %r15
movq %r14, %r12
movq -0x38(%rbp), %rax
jmp 0x8b6c
andq $0x0, 0x8(%r12)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8c1b
movq %rax, %r14
addq $0x18, %r12
movq %r12, %rdi
callq 0x3170
movq %r14, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::Matrix(int, int, double, ...)
Matrix::Matrix(int nRows, int nColumns, double first, ...)
{
	this->nRows = nRows;
	this->nColumns = nColumns;
	if ((nRows*nColumns) == 0)
	{
		values = NULL;
		return;
	}
	values = new double*[nRows];
	va_list va;
	va_start(va, first);
	for (int iR = 0;iR<nRows;iR++)
	{
		values[iR] = new double[nColumns];
		for (int iC = 0;iC<nColumns;iC++)
		{
			values[iR][iC] = (iC == 0 && iR == 0) ? first : va_arg(va, double);
		}
	}
	va_end(va);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movsd %xmm0, -0x48(%rbp)
movq %rdi, %rbx
movq %rcx, -0xe8(%rbp)
movq %r8, -0xe0(%rbp)
movq %r9, -0xd8(%rbp)
testb %al, %al
je 0x8c8f
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
leaq 0x28(%rdi), %rax
movq %rax, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %edx, %eax
imull %esi, %eax
testl %eax, %eax
je 0x8d7a
movl %edx, %r14d
movl %esi, %r15d
movl %esi, %edi
shlq $0x3, %rdi
testl %esi, %esi
pushq $-0x1
popq %rax
cmovsq %rax, %rdi
callq 0x3030
movq %rax, 0x8(%rbx)
leaq -0x100(%rbp), %rax
movq %rax, -0x30(%rbp)
movl %r14d, %r12d
shlq $0x3, %r12
xorl %r13d, %r13d
testl %r14d, %r14d
pushq $-0x1
popq %rax
cmovsq %rax, %r12
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movabsq $0x4000000018, %rax     # imm = 0x4000000018
cmovlel %r13d, %r14d
movq %rax, -0x40(%rbp)
testl %r15d, %r15d
cmovlel %r13d, %r15d
cmpq %r15, %r13
je 0x8d7f
movq %r12, %rdi
callq 0x3030
movq 0x8(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
movq 0x8(%rbx), %rax
xorl %ecx, %ecx
cmpq %rcx, %r14
je 0x8d75
movl %ecx, %edx
orl %r13d, %edx
movsd -0x48(%rbp), %xmm0
je 0x8d67
movl -0x3c(%rbp), %esi
cmpq $0xa0, %rsi
ja 0x8d57
movq %rsi, %rdx
addq -0x30(%rbp), %rdx
addl $0x10, %esi
movl %esi, -0x3c(%rbp)
jmp 0x8d63
movq -0x38(%rbp), %rdx
leaq 0x8(%rdx), %rsi
movq %rsi, -0x38(%rbp)
movsd (%rdx), %xmm0
movq (%rax,%r13,8), %rdx
movsd %xmm0, (%rdx,%rcx,8)
incq %rcx
jmp 0x8d2b
incq %r13
jmp 0x8d10
andq $0x0, 0x8(%rbx)
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8d93
movq %rax, %r14
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x3170
movq %r14, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::Matrix(Matrix&)
Matrix::Matrix(Matrix& m)
{
	nRows = nColumns = 0;
	values = NULL;
	cvalues=NULL;
	copy(m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x28(%rdi), %rax
movq %rax, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
leaq 0x18(%rdi), %rbx
movb $0x0, 0x28(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x8dee
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3170
movq %r14, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::copy(Matrix const&)
void Matrix::copy(const Matrix& m)
{
	reset();
	this->nRows = m.nRows;
	this->nColumns = m.nColumns;
	if ((nRows*nColumns) == 0)
	{
		values = NULL;
		cvalues=NULL;
		return;
	}
   if(m.type=="complex")
   {
     type="complex";
	 cvalues = new complex<double>*[nRows];
	 for (int iR = 0;iR<nRows;iR++)
	 {
		cvalues[iR] = new complex<double>[nColumns];
		for (int iC = 0;iC<nColumns;iC++)
		{
			cvalues[iR][iC] = m.cvalues[iR][iC];
		}
	 }
	}
   else
    {
	 values = new double*[nRows];
	 for (int iR = 0;iR<nRows;iR++)
	 {
		values[iR] = new double[nColumns];
		for (int iC = 0;iC<nColumns;iC++)
		{
			values[iR][iC] = m.values[iR][iC];
		}
	 }
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x8a44
movl (%r14), %eax
movl %eax, (%rbx)
movl 0x4(%r14), %ecx
movl %ecx, 0x4(%rbx)
imull %eax, %ecx
testl %ecx, %ecx
je 0x8ee5
leaq 0x18(%r14), %rdi
leaq 0x63c9(%rip), %rsi      # 0xf1f5
callq 0x795a
testb %al, %al
je 0x8efb
leaq 0x18(%rbx), %rdi
leaq 0x63b1(%rip), %rsi      # 0xf1f5
callq 0x35a0
movslq (%rbx), %r15
leaq (,%r15,8), %rdi
testq %r15, %r15
pushq $-0x1
popq %rax
cmovsq %rax, %rdi
callq 0x3030
movq %rax, 0x10(%rbx)
xorl %r13d, %r13d
movslq %r15d, %rax
cmpq %rax, %r13
jge 0x8eec
movslq 0x4(%rbx), %r15
movq %r15, %r12
shlq $0x4, %r12
testq %r15, %r15
movq %r12, %rdi
pushq $-0x1
popq %rax
cmovsq %rax, %rdi
callq 0x3030
testq %r15, %r15
je 0x8ea7
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x3210
movq %r15, %rax
movq 0x10(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
xorl %eax, %eax
xorl %ecx, %ecx
movslq 0x4(%rbx), %rdx
cmpq %rdx, %rcx
jge 0x8edd
movq 0x10(%r14), %rdx
movq (%rdx,%r13,8), %rdx
movq 0x10(%rbx), %rsi
movq (%rsi,%r13,8), %rsi
movups (%rdx,%rax), %xmm0
movups %xmm0, (%rsi,%rax)
incq %rcx
addq $0x10, %rax
jmp 0x8eb3
incq %r13
movl (%rbx), %r15d
jmp 0x8e6a
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movslq (%rbx), %rax
movq %rax, -0x30(%rbp)
leaq (,%rax,8), %rdi
testq %rax, %rax
pushq $-0x1
popq %r12
cmovsq %r12, %rdi
callq 0x3030
movq %rax, %r15
movq %rax, 0x8(%rbx)
movslq 0x4(%rbx), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
cmovsq %r12, %rcx
movq %rcx, -0x38(%rbp)
xorl %r13d, %r13d
testl %eax, %eax
movl $0x0, %r12d
cmovgl %eax, %r12d
movq -0x30(%rbp), %rcx
testl %ecx, %ecx
movl $0x0, %eax
cmovgl %ecx, %eax
movq %rax, -0x30(%rbp)
cmpq -0x30(%rbp), %r13
je 0x8eec
movq -0x38(%rbp), %rdi
callq 0x3030
movq %rax, (%r15,%r13,8)
movq 0x8(%r14), %rax
movq 0x8(%rbx), %r15
xorl %ecx, %ecx
cmpq %rcx, %r12
je 0x8f92
movq (%rax,%r13,8), %rdx
movsd (%rdx,%rcx,8), %xmm0
movq (%r15,%r13,8), %rdx
movsd %xmm0, (%rdx,%rcx,8)
incq %rcx
jmp 0x8f76
incq %r13
jmp 0x8f59
nop
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::Matrix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Matrix::Matrix(string s)
{
	nRows = nColumns = 0;
	values = NULL;
	cvalues = NULL;
	copy(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x28(%rdi), %rax
movq %rax, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq -0x30(%rbp), %rdi
callq 0x3410
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x9052
leaq -0x30(%rbp), %rdi
callq 0x3170
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x3170
jmp 0x903e
movq %rax, %r14
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x3170
movq %r14, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::Matrix(double)
Matrix::Matrix(double d)
{
	nRows = nColumns = 0;
	values = NULL;
	cvalues = NULL;
	copy(d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x28(%rdi), %rax
movq %rax, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
leaq 0x18(%rdi), %rbx
movb $0x0, 0x28(%rdi)
xorps %xmm1, %xmm1
movups %xmm1, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x9466
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3170
movq %r14, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::copy(double)
void Matrix::copy(double d)
{
	this->nRows = 1;
	this->nColumns = 1;
	if (this->type=="complex")
    {
    cvalues = new complex<double>*[1];
	cvalues[0] = new complex<double>[1];
	cvalues[0][0] = d;
    }
    else{
	values = new double*[1];
	values[0] = new double[1];
	values[0][0] = d;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, -0x20(%rbp)
movq %rdi, %rbx
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, (%rdi)
addq $0x18, %rdi
leaq 0x5d65(%rip), %rsi      # 0xf1f5
callq 0x795a
movl %eax, %r15d
pushq $0x8
popq %rdi
callq 0x3030
movq %rax, %r14
testb %r15b, %r15b
je 0x94c7
movq %r14, 0x10(%rbx)
pushq $0x10
popq %rdi
callq 0x3030
movq %rax, (%r14)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
andq $0x0, 0x8(%rax)
jmp 0x94df
movq %r14, 0x8(%rbx)
pushq $0x8
popq %rdi
callq 0x3030
movq %rax, (%r14)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::addColumn(Matrix&)
void Matrix::addColumn(Matrix& m)
{   if(m.type=="complex")
    {
    Matrix n("complex",max(nRows, m.nRows), nColumns + m.nColumns);
    n.setSubMatrix(0, 0, *this);
	n.setSubMatrix(0, nColumns, m);
	*this = n;
    }
    else
    {
	Matrix n(max(nRows, m.nRows), nColumns + m.nColumns);
	n.setSubMatrix(0, 0, *this);
	n.setSubMatrix(0, nColumns, m);
	*this = n;
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsi), %rdi
leaq 0x5a10(%rip), %rsi      # 0xf1f5
callq 0x795a
testb %al, %al
je 0x9873
leaq 0x59fc(%rip), %rsi      # 0xf1f5
leaq -0x78(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x7844
movl (%rbx), %eax
movl (%r14), %edx
movl 0x4(%r14), %ecx
cmpl %edx, %eax
cmovgl %eax, %edx
addl 0x4(%rbx), %ecx
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorl %r8d, %r8d
callq 0xe29a
leaq -0x78(%rbp), %rdi
callq 0x3170
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xb5e2
movl 0x4(%rbx), %edx
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0xb5e2
leaq -0xe8(%rbp), %rdi
leaq -0x58(%rbp), %rdx
movq %rbx, %rsi
callq 0x9e42
leaq -0xe8(%rbp), %rdi
jmp 0x98cf
movl (%rbx), %eax
movl (%r14), %esi
movl 0x4(%r14), %edx
cmpl %esi, %eax
cmovgl %eax, %esi
addl 0x4(%rbx), %edx
leaq -0x58(%rbp), %r15
xorps %xmm0, %xmm0
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x8ace
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xb5e2
movl 0x4(%rbx), %edx
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0xb5e2
leaq -0xb0(%rbp), %rdi
leaq -0x58(%rbp), %rdx
movq %rbx, %rsi
callq 0x9e42
leaq -0xb0(%rbp), %rdi
callq 0x8a24
leaq -0x58(%rbp), %rdi
callq 0x8a24
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x3170
jmp 0x990c
movq %rax, %rbx
jmp 0x990c
jmp 0x9900
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x8a24
movq %rbx, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::addRow(Matrix&)
void Matrix::addRow(Matrix& m)
{
    if(m.type=="complex")
        {
	Matrix n("complex",nRows + m.nRows, max(nColumns, m.nColumns));
	n.setSubMatrix(0, 0, *this);
	n.setSubMatrix(nRows, 0, m);
	*this = n;
        }
	else
      {
    Matrix n(nRows + m.nRows, max(nColumns, m.nColumns));
	n.setSubMatrix(0, 0, *this);
	n.setSubMatrix(nRows, 0, m);
	*this = n;
      }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsi), %rdi
leaq 0x58c0(%rip), %rsi      # 0xf1f5
callq 0x795a
testb %al, %al
je 0x99c2
leaq 0x58ac(%rip), %rsi      # 0xf1f5
leaq -0x78(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x7844
movl (%r14), %edx
movl 0x4(%r14), %ecx
addl (%rbx), %edx
movl 0x4(%rbx), %eax
cmpl %ecx, %eax
cmovgl %eax, %ecx
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorl %r8d, %r8d
callq 0xe29a
leaq -0x78(%rbp), %rdi
callq 0x3170
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xb5e2
movl (%rbx), %esi
leaq -0x58(%rbp), %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0xb5e2
leaq -0xe8(%rbp), %rdi
leaq -0x58(%rbp), %rdx
movq %rbx, %rsi
callq 0x9e42
leaq -0xe8(%rbp), %rdi
jmp 0x9a1d
movl (%r14), %esi
movl 0x4(%r14), %edx
addl (%rbx), %esi
movl 0x4(%rbx), %eax
cmpl %edx, %eax
cmovgl %eax, %edx
leaq -0x58(%rbp), %r15
xorps %xmm0, %xmm0
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x8ace
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xb5e2
movl (%rbx), %esi
leaq -0x58(%rbp), %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0xb5e2
leaq -0xb0(%rbp), %rdi
leaq -0x58(%rbp), %rdx
movq %rbx, %rsi
callq 0x9e42
leaq -0xb0(%rbp), %rdi
callq 0x8a24
leaq -0x58(%rbp), %rdi
callq 0x8a24
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x3170
jmp 0x9a5a
movq %rax, %rbx
jmp 0x9a5a
jmp 0x9a4e
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x8a24
movq %rbx, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::getAltString[abi:cxx11]()
string Matrix::getAltString()
{
    string s="[";
    for (int iR=0;iR<nRows;iR++)
    {
        for (int iC=0;iC<nColumns;iC++)
        {
            char buffer[50]="";
            if(iC<nColumns-1)
            snprintf(buffer,50,"%g ", values[iR][iC]);
            else
                 snprintf(buffer,50,"%g", values[iR][iC]);
            s+= buffer;
        }
        if(iR < nRows-1)
        s+= ';';
        else
        s+=']';
    }
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x541e(%rip), %rsi      # 0xf0b6
leaq -0x60(%rbp), %r15
movq %r15, %rdx
callq 0x7844
xorl %r13d, %r13d
movslq (%r14), %rax
cmpq %rax, %r13
jge 0x9d38
xorl %r12d, %r12d
movslq 0x4(%r14), %rax
cmpq %rax, %r12
jge 0x9d16
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
andw $0x0, -0x30(%rbp)
decq %rax
cmpq %rax, %r12
movq 0x8(%r14), %rax
movq (%rax,%r13,8), %rax
movsd (%rax,%r12,8), %xmm0
leaq 0x5554(%rip), %rdx      # 0xf242
leaq 0x5549(%rip), %rax      # 0xf23e
cmovlq %rax, %rdx
movq %r15, %rdi
pushq $0x32
popq %rsi
movb $0x1, %al
callq 0x3480
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3590
incq %r12
jmp 0x9cb6
movslq (%r14), %rax
decq %rax
cmpq %rax, %r13
pushq $0x5d
popq %rsi
pushq $0x3b
popq %rax
cmovll %eax, %esi
movq %rbx, %rdi
callq 0x32c0
incq %r13
jmp 0x9ca7
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9d4c
movq %rax, %r14
movq %rbx, %rdi
callq 0x3170
movq %r14, %rdi
callq 0x3520
nop
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::getAltStringNoB[abi:cxx11]()
string Matrix::getAltStringNoB()
{
    string s="";
    for (int iR=0;iR<nRows;iR++)
    {
        for (int iC=0;iC<nColumns;iC++)
        {
            char buffer[50]="";
            if(iC<nColumns-1)
            snprintf(buffer,50,"%g ", values[iR][iC]);
            else
                 snprintf(buffer,50,"%g", values[iR][iC]);
            s+= buffer;
        }
        if(iR < nRows-1)
        s+= ';';
//        else
//        s+=']';
    }
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x54a4(%rip), %rsi      # 0xf222
leaq -0x60(%rbp), %r15
movq %r15, %rdx
callq 0x7844
xorl %r13d, %r13d
movslq (%r14), %rax
cmpq %rax, %r13
jge 0x9e1a
xorl %r12d, %r12d
movslq 0x4(%r14), %rax
cmpq %rax, %r12
jge 0x9dfc
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
andw $0x0, -0x30(%rbp)
decq %rax
cmpq %rax, %r12
movq 0x8(%r14), %rax
movq (%rax,%r13,8), %rax
movsd (%rax,%r12,8), %xmm0
leaq 0x546e(%rip), %rdx      # 0xf242
leaq 0x5463(%rip), %rax      # 0xf23e
cmovlq %rax, %rdx
movq %r15, %rdi
pushq $0x32
popq %rsi
movb $0x1, %al
callq 0x3480
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3590
incq %r12
jmp 0x9d9c
movslq (%r14), %rax
decq %rax
cmpq %rax, %r13
jge 0x9e12
movq %rbx, %rdi
pushq $0x3b
popq %rsi
callq 0x32c0
incq %r13
jmp 0x9d8d
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9e2e
movq %rax, %r14
movq %rbx, %rdi
callq 0x3170
movq %r14, %rdi
callq 0x3520
nop
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::add(Matrix const&)
void Matrix::add(const Matrix& m)
{
	if (nRows != m.nRows || nColumns != m.nColumns)
		throw("Invalid matrix dimension");
	for (int iR = 0; iR < nRows; iR++)
	{
		for (int iC = 0;iC < nColumns;iC++)
    {
      if((this->type=="complex") && (m.type=="complex"))
        cvalues[iR][iC] += m.cvalues[iR][iC];
      else if((this->type=="complex") && (m.type!="complex"))
        cvalues[iR][iC] += m.values[iR][iC];
      else if((this->type!="complex") && (m.type=="complex"))
        cvalues[iR][iC] =values[iR][iC]+m.cvalues[iR][iC];
      else
        values[iR][iC] += m.values[iR][iC];
    }

	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl (%rdi), %ecx
cmpl (%rsi), %ecx
jne 0xa09c
movq %rsi, %r14
movl 0x4(%rdi), %eax
cmpl 0x4(%rsi), %eax
jne 0xa09c
leaq 0x18(%rdi), %rdx
movq %rdx, -0x40(%rbp)
leaq 0x18(%r14), %rdx
movq %rdx, -0x38(%rbp)
xorl %r15d, %r15d
leaq 0x52df(%rip), %r13      # 0xf1f5
movq %rdi, -0x30(%rbp)
movslq %ecx, %rcx
cmpq %rcx, %r15
jge 0xa08d
xorl %r12d, %r12d
xorl %ebx, %ebx
movslq %eax, %rcx
cmpq %rcx, %rbx
jge 0xa083
movq -0x40(%rbp), %rdi
movq %r13, %rsi
callq 0x795a
testb %al, %al
je 0x9f97
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x795a
testb %al, %al
je 0x9f97
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rax
movq -0x30(%rbp), %rdi
movq 0x10(%rdi), %rcx
movq (%rcx,%r15,8), %rcx
movsd (%rax,%r12,2), %xmm0
movsd 0x8(%rax,%r12,2), %xmm1
addsd (%rcx,%r12,2), %xmm0
addsd 0x8(%rcx,%r12,2), %xmm1
movsd %xmm0, (%rcx,%r12,2)
movsd %xmm1, 0x8(%rcx,%r12,2)
jmp 0xa074
movq -0x40(%rbp), %rdi
movq %r13, %rsi
callq 0x795a
testb %al, %al
je 0x9fe2
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x78c0
testb %al, %al
je 0x9fe2
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movsd (%rax,%r12), %xmm0
movq -0x30(%rbp), %rdi
movq 0x10(%rdi), %rax
movq (%rax,%r15,8), %rax
addsd (%rax,%r12,2), %xmm0
movsd %xmm0, (%rax,%r12,2)
jmp 0xa074
movq %rbx, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq %r13, %rbx
movq %r13, %rsi
callq 0x78c0
testb %al, %al
je 0xa047
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x795a
testb %al, %al
je 0xa047
movq -0x30(%rbp), %rdi
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
movq (%rax,%r15,8), %rax
movq 0x10(%r14), %rdx
movq (%rdx,%r15,8), %rdx
movsd (%rdx,%r12,2), %xmm0
addsd (%rax,%r12), %xmm0
movsd 0x8(%rdx,%r12,2), %xmm1
movq (%rcx,%r15,8), %rax
movsd %xmm0, (%rax,%r12,2)
movsd %xmm1, 0x8(%rax,%r12,2)
jmp 0xa06d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movsd (%rax,%r12), %xmm0
movq -0x30(%rbp), %rdi
movq 0x8(%rdi), %rax
movq (%rax,%r15,8), %rax
addsd (%rax,%r12), %xmm0
movsd %xmm0, (%rax,%r12)
movq %rbx, %r13
movq -0x48(%rbp), %rbx
incq %rbx
movl 0x4(%rdi), %eax
addq $0x8, %r12
jmp 0x9f2b
incq %r15
movl (%rdi), %ecx
jmp 0x9f1a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x31a0
leaq 0x519a(%rip), %rcx      # 0xf245
movq %rcx, (%rax)
movq 0x9f13(%rip), %rsi      # 0x13fc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x34e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::sub(Matrix const&)
void Matrix::sub(const Matrix& m)
{
	if (nRows != m.nRows || nColumns != m.nColumns)
		throw("Invalid matrix dimension");
	for (int iR = 0;iR < nRows;iR++)
	{
		for (int iC = 0;iC < nColumns;iC++)
    {
      if((this->type=="complex") && (m.type=="complex"))
        cvalues[iR][iC] -= m.cvalues[iR][iC];
      else if((this->type=="complex") && (m.type!="complex"))
        cvalues[iR][iC] -= m.values[iR][iC];
      else if((this->type!="complex") && (m.type=="complex"))
        cvalues[iR][iC] =values[iR][iC]-m.cvalues[iR][iC];
      else
        values[iR][iC] -= m.values[iR][iC];
    }
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl (%rdi), %ecx
cmpl (%rsi), %ecx
jne 0xa446
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%rdi), %eax
cmpl 0x4(%rsi), %eax
jne 0xa446
leaq 0x18(%rbx), %rdx
movq %rdx, -0x38(%rbp)
leaq 0x18(%r14), %rdx
movq %rdx, -0x30(%rbp)
xorl %r15d, %r15d
leaq 0x4f2e(%rip), %r13      # 0xf1f5
movslq %ecx, %rcx
cmpq %rcx, %r15
jge 0xa437
xorl %r12d, %r12d
xorl %edx, %edx
movslq %eax, %rcx
cmpq %rcx, %rdx
jge 0xa42d
movq %rdx, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x795a
testb %al, %al
je 0xa344
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0x795a
testb %al, %al
je 0xa344
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rax
movq 0x10(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
movsd (%rcx,%r12,2), %xmm0
movsd 0x8(%rcx,%r12,2), %xmm1
subsd (%rax,%r12,2), %xmm0
subsd 0x8(%rax,%r12,2), %xmm1
movsd %xmm0, (%rcx,%r12,2)
movsd %xmm1, 0x8(%rcx,%r12,2)
jmp 0xa41a
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x795a
testb %al, %al
je 0xa38b
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0x78c0
testb %al, %al
je 0xa38b
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movq 0x10(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
movsd (%rcx,%r12,2), %xmm0
subsd (%rax,%r12), %xmm0
movsd %xmm0, (%rcx,%r12,2)
jmp 0xa41a
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x78c0
testb %al, %al
je 0xa3f1
movq -0x30(%rbp), %rdi
leaq 0x4e4f(%rip), %rsi      # 0xf1f5
callq 0x795a
testb %al, %al
je 0xa3f1
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movq (%rax,%r15,8), %rax
movq 0x10(%r14), %rdx
movq (%rdx,%r15,8), %rdx
movsd 0x8(%rdx,%r12,2), %xmm0
movsd (%rax,%r12), %xmm1
subsd (%rdx,%r12,2), %xmm1
xorpd 0x4de2(%rip), %xmm0     # 0xf1c0
movq (%rcx,%r15,8), %rax
movsd %xmm1, (%rax,%r12,2)
movlpd %xmm0, 0x8(%rax,%r12,2)
jmp 0xa413
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movq 0x8(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
movsd (%rcx,%r12), %xmm0
subsd (%rax,%r12), %xmm0
movsd %xmm0, (%rcx,%r12)
leaq 0x4ddb(%rip), %r13      # 0xf1f5
movq -0x40(%rbp), %rdx
incq %rdx
movl 0x4(%rbx), %eax
addq $0x8, %r12
jmp 0xa2d8
incq %r15
movl (%rbx), %ecx
jmp 0xa2c7
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x31a0
leaq 0x4df0(%rip), %rcx      # 0xf245
movq %rcx, (%rax)
movq 0x9b69(%rip), %rsi      # 0x13fc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x34e0
nop