LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: MPSLab-ASU[P]DiRAC/./src/pe.cc
// Function: PE::initialize()
void PE::initialize()
{
  PE_State = idle;
  // ToDO: Decouple double-buffer management for netwro-FIFO interface vs.
  // that for PE processing data from RegFille.
  // In other words, two double-buffer indices each for communicate and compute
  // can allow managing variable interconnect networks vs. 3 operands of PE.
  regs_startIdx_Op1[0] = regs_buf1_startIdx_Op[0];
  regs_startIdx_Op2[0] = regs_buf1_startIdx_Op[1];
  regs_startIdx_Op3[0] = regs_buf1_startIdx_Op[2];
  regs_startIdx_Op1[1] = regs_buf2_startIdx_Op[0];
  regs_startIdx_Op2[1] = regs_buf2_startIdx_Op[1];
  regs_startIdx_Op3[1] = regs_buf2_startIdx_Op[2];
  buf_to_reg_idx_Op1 = regs_startIdx_Op1[0];
  buf_to_reg_idx_Op2 = regs_startIdx_Op2[0];
  buf_to_reg_idx_Op3 = regs_startIdx_Op3[0];
  reg_to_buf_idx_Op1 = regs_startIdx_Op3[0];
  // reg_read_Op1 = regs_startIdx_Op1;   // ifmaps
  // reg_read_Op2 = regs_startIdx_Op2; // weights
  // reg_read_Op3 = regs_startIdx_Op3;    // ofmap
  buffer_number_comm_op[0] = 0;
  buffer_number_comp_op[0] = 1;
  buffer_number_comm_op[1] = 0;
  buffer_number_comp_op[1] = 1;
  buffer_number_comm_op[2] = 0;
  buffer_number_comp_op[2] = 1;

  counter_PE_exec = 0;
  counter_PE_WB = 0;
  counter_writeback_Op1 = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq $0x61e5d0, %rcx         # imm = 0x61E5D0
movq (%rcx), %rcx
movw (%rcx), %cx
movw %cx, 0xf8(%rax)
movq $0x61e5d0, %rcx         # imm = 0x61E5D0
movq (%rcx), %rcx
movw 0x2(%rcx), %cx
movw %cx, 0xfc(%rax)
movq $0x61e5d0, %rcx         # imm = 0x61E5D0
movq (%rcx), %rcx
movw 0x4(%rcx), %cx
movw %cx, 0x100(%rax)
movq $0x61e5d8, %rcx         # imm = 0x61E5D8
movq (%rcx), %rcx
movw (%rcx), %cx
movw %cx, 0xfa(%rax)
movq $0x61e5d8, %rcx         # imm = 0x61E5D8
movq (%rcx), %rcx
movw 0x2(%rcx), %cx
movw %cx, 0xfe(%rax)
movq $0x61e5d8, %rcx         # imm = 0x61E5D8
movq (%rcx), %rcx
movw 0x4(%rcx), %cx
movw %cx, 0x102(%rax)
movw 0xf8(%rax), %cx
movw %cx, 0x26(%rax)
movw 0xfc(%rax), %cx
movw %cx, 0x28(%rax)
movw 0x100(%rax), %cx
movw %cx, 0x2a(%rax)
movw 0x100(%rax), %cx
movw %cx, 0x2c(%rax)
movb $0x0, 0xde(%rax)
movb $0x1, 0xe1(%rax)
movb $0x0, 0xdf(%rax)
movb $0x1, 0xe2(%rax)
movb $0x0, 0xe0(%rax)
movb $0x1, 0xe3(%rax)
movw $0x0, 0x9c(%rax)
movw $0x0, 0x38(%rax)
movw $0x0, 0x36(%rax)
popq %rbp
retq
nopl (%rax)
// File: MPSLab-ASU[P]DiRAC/./src/pe.cc
// Function: PE::setTriggerFromController(bool*, bool*, bool*, bool*, bool*, bool*, bool*)
void PE::setTriggerFromController(bool *inBus_exec, bool *inBus_zero_initialize,
  bool *inBus_write_back, bool *inBus_spatial_reduction,
  bool *inBus_update_buf_Op1, bool *inBus_update_buf_Op2,
  bool *inBus_update_buf_Op3)
{
  trigger_from_controller_PE_exec             = inBus_exec;
  trigger_from_controller_zero_initialize     = inBus_zero_initialize;
  trigger_from_controller_write_back          = inBus_write_back;
  trigger_from_controller_spatial_reduce      = inBus_spatial_reduction;
  trigger_from_controller_update_buf_num_Op1  = inBus_update_buf_Op1;
  trigger_from_controller_update_buf_num_Op2  = inBus_update_buf_Op2;
  trigger_from_controller_update_buf_num_Op3  = inBus_update_buf_Op3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0xa0(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0xa8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0xb0(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0xb8(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0xc0(%rax)
movq 0x10(%rbp), %rcx
movq %rcx, 0xc8(%rax)
movq 0x18(%rbp), %rcx
movq %rcx, 0xd0(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x48(%rax), %rax
movq (%rax), %rdi
callq 0x4243f0
testb $0x1, %al
jne 0x42323c
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rdi
callq 0x424410
movq -0x18(%rbp), %rdi
movw %ax, -0xa(%rbp)
movw 0x26(%rdi), %ax
movzwl %ax, %esi
movzwl -0xa(%rbp), %edx
callq 0x4232f0
movq -0x18(%rbp), %rax
movw 0x26(%rax), %cx
addw $0x1, %cx
movw %cx, 0x26(%rax)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x4243f0
testb $0x1, %al
jne 0x42328a
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x424410
movq -0x18(%rbp), %rdi
movw %ax, -0xc(%rbp)
movw 0x28(%rdi), %ax
movzwl %ax, %esi
movzwl -0xc(%rbp), %edx
callq 0x4232f0
movq -0x18(%rbp), %rax
movw 0x28(%rax), %cx
addw $0x1, %cx
movw %cx, 0x28(%rax)
movq $0x61c151, %rax         # imm = 0x61C151
movzbl (%rax), %eax
cmpl $0x2, %eax
jle 0x4232e9
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x4243f0
testb $0x1, %al
jne 0x4232e7
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x424410
movq -0x18(%rbp), %rdi
movw %ax, -0xe(%rbp)
movw 0x2a(%rdi), %ax
movzwl %ax, %esi
movzwl -0xe(%rbp), %edx
callq 0x4232f0
movq -0x18(%rbp), %rax
movw 0x2a(%rax), %cx
addw $0x1, %cx
movw %cx, 0x2a(%rax)
jmp 0x4232e9
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
movq $0x61e5e4, %rcx         # imm = 0x61E5E4
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x4233ed
movq -0x18(%rbp), %rax
testb $0x1, 0x138(%rax)
je 0x4233cf
movq -0x18(%rbp), %rax
movzwl 0x38(%rax), %eax
movq $0x61c150, %rcx         # imm = 0x61C150
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jl 0x4233cf
movq -0x18(%rbp), %rcx
movzwl 0x36(%rcx), %eax
movzwl 0x34(%rcx), %ecx
cmpl %ecx, %eax
jge 0x4233cd
movq -0x18(%rbp), %rax
movq %rax, %rdi
movzwl 0x2c(%rax), %esi
callq 0x423400
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, -0xc(%rbp)
movq 0x50(%rax), %rax
movzbl -0x9(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
movzwl -0xc(%rbp), %esi
callq 0x424460
movq -0x18(%rbp), %rax
movw 0x2c(%rax), %cx
addw $0x1, %cx
movw %cx, 0x2c(%rax)
movw 0x36(%rax), %cx
addw $0x1, %cx
movw %cx, 0x36(%rax)
jmp 0x4233de
movq -0x18(%rbp), %rax
movzwl 0x38(%rax), %ecx
addl $0x1, %ecx
movw %cx, 0x38(%rax)
jmp 0x4233e0
movb -0x9(%rbp), %al
addb $0x1, %al
movb %al, -0x9(%rbp)
jmp 0x423338
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: MPSLab-ASU[P]DiRAC/./src/pe.cc
// Function: PE::executeAtTick()
void PE::executeAtTick()
{
  // Pop data from output FIFOs to output networks
  execute_out_buf_read();

  // Push data from RF to output FIFO
  // Following condition (introducing delay slot) is needed only if PEs are
  // triggered for both execution and Write-Back at the same time.
  writeBuffers();

  if (PE_State == execute || state_write_RF)
  {
    execute_pipeline();
  }

  determine_next_state();

  // Populate RF from Input FIFOs if new data element(s) has arrived.
  readBuffers();

  // Pop data from input networks to input FIFOs
  execute_in_buf_write();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x4234a0
movq -0x10(%rbp), %rdi
callq 0x423320
movq -0x10(%rbp), %rax
cmpl $0x1, 0x8(%rax)
je 0x423469
movq -0x10(%rbp), %rax
testb $0x1, 0x98(%rax)
je 0x423472
movq -0x10(%rbp), %rdi
callq 0x423550
movq -0x10(%rbp), %rdi
callq 0x423610
movq -0x10(%rbp), %rdi
callq 0x4231e0
movq -0x10(%rbp), %rdi
callq 0x4238d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
movq $0x61e5e4, %rcx         # imm = 0x61E5E4
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x423546
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movzbl -0x9(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x4243f0
testb $0x1, %al
jne 0x423519
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movzbl -0x9(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x424410
movw %ax, %si
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rcx
movzbl -0x9(%rbp), %edx
movw %si, (%rcx,%rdx,2)
movq 0x70(%rax), %rax
movzbl -0x9(%rbp), %ecx
movb $0x1, (%rax,%rcx)
jmp 0x423537
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rcx
movzbl -0x9(%rbp), %edx
movb $0x0, (%rcx,%rdx)
movq 0x78(%rax), %rax
movzbl -0x9(%rbp), %ecx
movw $0x0, (%rax,%rcx,2)
jmp 0x423539
movb -0x9(%rbp), %al
addb $0x1, %al
movb %al, -0x9(%rbp)
jmp 0x4234b8
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movb 0x98(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x42357d
movq -0x10(%rbp), %rdi
callq 0x423c70
movq -0x10(%rbp), %rdi
callq 0x423cc0
movq -0x10(%rbp), %rax
movb 0x82(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4235a3
movq -0x10(%rbp), %rdi
callq 0x423cf0
movq -0x10(%rbp), %rax
movb 0x81(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4235c7
movq -0x10(%rbp), %rdi
movq 0xf0(%rdi), %rsi
callq 0x423d50
movq -0x10(%rbp), %rax
movb 0x80(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4235f8
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rcx
movzwl 0x9c(%rax), %edx
movq (%rcx,%rdx,8), %rcx
movq %rcx, 0xf0(%rax)
movq -0x10(%rbp), %rdi
callq 0x423ea0
movq -0x10(%rbp), %rdi
callq 0x423f10
addq $0x10, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x1, 0xc(%rax)
jne 0x42397f
movq -0x10(%rbp), %rax
movl $0x1, 0x8(%rax)
movb $0x1, 0x80(%rax)
movl $0x0, 0xc(%rax)
movq -0x10(%rbp), %rax
movb 0xd9(%rax), %cl
andb $0x1, %cl
movb %cl, 0x128(%rax)
movb $0x0, 0xd9(%rax)
testb $0x1, 0xdb(%rax)
je 0x4239e9
movq -0x10(%rbp), %rax
movzbl 0xe1(%rax), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movq -0x10(%rbp), %rax
movb %dl, %cl
movb %cl, 0xe1(%rax)
movzbl 0xde(%rax), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movq -0x10(%rbp), %rax
movb %dl, %cl
movb %cl, 0xde(%rax)
movb $0x0, 0xdb(%rax)
movq -0x10(%rbp), %rax
testb $0x1, 0xdc(%rax)
je 0x423a3d
movq -0x10(%rbp), %rax
movzbl 0xe2(%rax), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movq -0x10(%rbp), %rax
movb %dl, %cl
movb %cl, 0xe2(%rax)
movzbl 0xdf(%rax), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movq -0x10(%rbp), %rax
movb %dl, %cl
movb %cl, 0xdf(%rax)
movb $0x0, 0xdc(%rax)
movq -0x10(%rbp), %rax
testb $0x1, 0xdd(%rax)
je 0x423a91
movq -0x10(%rbp), %rax
movzbl 0xe3(%rax), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movq -0x10(%rbp), %rax
movb %dl, %cl
movb %cl, 0xe3(%rax)
movzbl 0xe0(%rax), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movq -0x10(%rbp), %rax
movb %dl, %cl
movb %cl, 0xe0(%rax)
movb $0x0, 0xdd(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: MPSLab-ASU[P]DiRAC/./src/pe.cc
// Function: PE::update_reg_idx_Ops()
void PE::update_reg_idx_Ops()
{
  // ToDO: Make the following parameterized per #networks for inputs/outputs
  buf_to_reg_idx_Op1 = regs_startIdx_Op1[buffer_number_comm_op[0]];
  buf_to_reg_idx_Op2 = regs_startIdx_Op2[buffer_number_comm_op[1]];
  buf_to_reg_idx_Op3 = regs_startIdx_Op3[buffer_number_comm_op[2]];
  reg_to_buf_idx_Op1 = regs_startIdx_Op3[buffer_number_comm_op[2]];
  reg_idx_Op1_comp = regs_startIdx_Op1[buffer_number_comp_op[0]];
  reg_idx_Op2_comp = regs_startIdx_Op2[buffer_number_comp_op[1]];
  reg_idx_Op3_comp = regs_startIdx_Op3[buffer_number_comp_op[2]];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0xde(%rax), %ecx
movw 0xf8(%rax,%rcx,2), %cx
movw %cx, 0x26(%rax)
movzbl 0xdf(%rax), %ecx
movw 0xfc(%rax,%rcx,2), %cx
movw %cx, 0x28(%rax)
movzbl 0xe0(%rax), %ecx
movw 0x100(%rax,%rcx,2), %cx
movw %cx, 0x2a(%rax)
movzbl 0xe0(%rax), %ecx
movw 0x100(%rax,%rcx,2), %cx
movw %cx, 0x2c(%rax)
movzbl 0xe1(%rax), %ecx
movw 0xf8(%rax,%rcx,2), %cx
movw %cx, 0x2e(%rax)
movzbl 0xe2(%rax), %ecx
movw 0xfc(%rax,%rcx,2), %cx
movw %cx, 0x30(%rax)
movzbl 0xe3(%rax), %ecx
movw 0x100(%rax,%rcx,2), %cx
movw %cx, 0x32(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: MPSLab-ASU[P]DiRAC/./src/pe.cc
// Function: PE::update_trigger_states_write_data()
void PE::update_trigger_states_write_data()
{
  if(PE_WB_next_pass == true)
  {
    sig_write_back_current_RF_Pass = PE_WB_next_pass;
    PE_WB_next_pass = false;
    counter_PE_WB = 0;
    counter_writeback_Op1 = 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movb 0xd8(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x423b86
movq -0x10(%rbp), %rax
movb 0xd8(%rax), %cl
andb $0x1, %cl
movb %cl, 0x138(%rax)
movb $0x0, 0xd8(%rax)
movw $0x0, 0x38(%rax)
movw $0x0, 0x36(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x61c154, %rax         # imm = 0x61C154
movzbl (%rax), %eax
movq $0x61c155, %rcx         # imm = 0x61C155
movzbl (%rcx), %ecx
addl %ecx, %eax
subl $0x1, %eax
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x0, %eax
jle 0x423dbc
movq -0x20(%rbp), %rax
movq 0x140(%rax), %rcx
movzbl -0x11(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movb (%rcx,%rdx), %dl
movq 0x140(%rax), %rax
movzbl -0x11(%rbp), %ecx
andb $0x1, %dl
movb %dl, (%rax,%rcx)
movb -0x11(%rbp), %al
addb $-0x1, %al
movb %al, -0x11(%rbp)
jmp 0x423d80
movq -0x20(%rbp), %rax
movb 0x139(%rax), %cl
movq 0x140(%rax), %rax
andb $0x1, %cl
movb %cl, (%rax)
movq $0x61c154, %rax         # imm = 0x61C154
movzbl (%rax), %eax
movq $0x61c155, %rcx         # imm = 0x61C155
movzbl (%rcx), %ecx
addl %ecx, %eax
movb %al, -0x12(%rbp)
movzbl -0x12(%rbp), %eax
cmpl $0x0, %eax
jle 0x423e26
movq -0x20(%rbp), %rax
movq 0x120(%rax), %rcx
movzbl -0x12(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movw (%rcx,%rdx,2), %dx
movq 0x120(%rax), %rax
movzbl -0x12(%rbp), %ecx
movw %dx, (%rax,%rcx,2)
movb -0x12(%rbp), %al
addb $-0x1, %al
movb %al, -0x12(%rbp)
jmp 0x423deb
movq -0x20(%rbp), %rax
movw 0x24(%rax), %dx
movq 0x120(%rax), %rcx
movw %dx, (%rcx)
movq -0x10(%rbp), %rcx
andq $0x1, %rcx
cmpq $0x0, %rcx
setne %cl
andb $0x1, %cl
movb %cl, 0x139(%rax)
movzwl 0x32(%rax), %ecx
movq -0x10(%rbp), %rdx
shrq $0x8, %rdx
andq $0xff, %rdx
addq %rdx, %rcx
movw %cx, 0x24(%rax)
movzwl 0x30(%rax), %ecx
movq -0x10(%rbp), %rdx
shrq $0x10, %rdx
andq $0xff, %rdx
addq %rdx, %rcx
movw %cx, 0x22(%rax)
movzwl 0x2e(%rax), %ecx
movq -0x10(%rbp), %rdx
shrq $0x18, %rdx
andq $0xff, %rdx
addq %rdx, %rcx
movw %cx, 0x20(%rax)
popq %rbp
retq
// File: MPSLab-ASU[P]DiRAC/./src/pe.cc
// Function: PE::update_FFs()
void PE::update_FFs()
{
  // Update FlipFlops for copying signal for mux in first stage of multiplier,
  // which decides to select potential value (propagated in pipeline)
  // for operand2 of addition; initialization of accumulation is
  // selected between zero value vs. register read of Op3.
  // Signal is set before executing fetch stage (upon trigger for an RF pass),
  // and then signal gets propagated through fetch, decode, and RF read,
  // before it reaches to multiplier stage 0.
  for(uint8_t it=2; it>0; it--)
    temp_sel_sig_adder_Op2_zero_initialize_current_RF_Pass[it] = temp_sel_sig_adder_Op2_zero_initialize_current_RF_Pass[it-1];
  temp_sel_sig_adder_Op2_zero_initialize_current_RF_Pass[0] = sel_sig_adder_Op2_zero_initialize_current_RF_Pass;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x2, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
cmpl $0x0, %eax
jle 0x423ef0
movq -0x18(%rbp), %rax
movq 0x130(%rax), %rcx
movzbl -0x9(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movb (%rcx,%rdx), %dl
movq 0x130(%rax), %rax
movzbl -0x9(%rbp), %ecx
andb $0x1, %dl
movb %dl, (%rax,%rcx)
movb -0x9(%rbp), %al
addb $-0x1, %al
movb %al, -0x9(%rbp)
jmp 0x423eb4
movq -0x18(%rbp), %rax
movb 0x128(%rax), %cl
movq 0x130(%rax), %rax
andb $0x1, %cl
movb %cl, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x90(%rax), %rcx
movq $0x61c155, %rdx         # imm = 0x61C155
movzbl (%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
movb (%rcx,%rdx), %cl
andb $0x1, %cl
movb %cl, 0x98(%rax)
movq $0x61c155, %rax         # imm = 0x61C155
movzbl (%rax), %eax
subl $0x1, %eax
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
cmpl $0x0, %eax
jle 0x423f8f
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rcx
movzbl -0x9(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movb (%rcx,%rdx), %dl
movq 0x90(%rax), %rax
movzbl -0x9(%rbp), %ecx
andb $0x1, %dl
movb %dl, (%rax,%rcx)
movb -0x9(%rbp), %al
addb $-0x1, %al
movb %al, -0x9(%rbp)
jmp 0x423f53
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rcx
movq $0x61c154, %rdx         # imm = 0x61C154
movzbl (%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
movb (%rcx,%rdx), %cl
movq 0x90(%rax), %rax
andb $0x1, %cl
movb %cl, (%rax)
movq $0x61c154, %rax         # imm = 0x61C154
movzbl (%rax), %eax
subl $0x1, %eax
movb %al, -0xa(%rbp)
movzbl -0xa(%rbp), %eax
cmpl $0x0, %eax
jle 0x424005
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rcx
movzbl -0xa(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movb (%rcx,%rdx), %dl
movq 0x88(%rax), %rax
movzbl -0xa(%rbp), %ecx
andb $0x1, %dl
movb %dl, (%rax,%rcx)
movb -0xa(%rbp), %al
addb $-0x1, %al
movb %al, -0xa(%rbp)
jmp 0x423fc9
movq -0x18(%rbp), %rax
movb 0x82(%rax), %dl
movq 0x88(%rax), %rcx
andb $0x1, %dl
movb %dl, (%rcx)
movb 0x81(%rax), %cl
andb $0x1, %cl
movb %cl, 0x82(%rax)
movb 0x80(%rax), %cl
andb $0x1, %cl
movb %cl, 0x81(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x61c154, %rax         # imm = 0x61C154
movzbl (%rax), %eax
subl $0x1, %eax
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
cmpl $0x0, %eax
jle 0x42409b
movq -0x18(%rbp), %rax
movq 0x108(%rax), %rcx
movzbl -0x9(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movw (%rcx,%rdx,2), %dx
movq 0x108(%rax), %rax
movzbl -0x9(%rbp), %ecx
movw %dx, (%rax,%rcx,2)
movb -0x9(%rbp), %al
addb $-0x1, %al
movb %al, -0x9(%rbp)
jmp 0x424060
movq -0x18(%rbp), %rax
movq 0x108(%rax), %rcx
movq $0x61c154, %rdx         # imm = 0x61C154
movzbl (%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
movw (%rcx,%rdx,2), %dx
movq 0x110(%rax), %rcx
movw %dx, (%rcx)
movq 0x88(%rax), %rax
testb $0x1, (%rax)
je 0x4240e9
movq -0x18(%rbp), %rax
movzwl 0x3a(%rax), %ecx
movzwl 0x3c(%rax), %edx
imull %edx, %ecx
movq 0x108(%rax), %rax
movw %cx, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, %rsi
movq %rsi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3180
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movslq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3550
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x3a81
movslq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x3720
movq %rax, -0x50(%rbp)
jmp 0x3a46
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x3a74
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3a74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3270
jmp 0x3a99
jmp 0x3a76
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x3a16
movl -0x2c(%rbp), %eax
movl %eax, -0x54(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3270
movl -0x54(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3630
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3550
movq %rax, %rcx
movq -0x48(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x3b9f
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x3720
movsbl (%rax), %eax
cmpl $0x5d, %eax
jne 0x3b8f
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rdx
movl $0x5b, %esi
callq 0x32a0
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq -0x30(%rbp), %rdi
callq 0x33e0
leaq -0x30(%rbp), %rdi
movl $0x20, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3360
cmpq $-0x1, %rax
je 0x3b52
jmp 0x3b86
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
leaq 0x1772f(%rip), %rcx     # 0x1b290
movl $0x1, %edx
callq 0x3260
jmp 0x3b6d
jmp 0x3b86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3270
jmp 0x3ba5
leaq -0x30(%rbp), %rdi
callq 0x3270
jmp 0x3b91
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3ac3
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3630
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x3720
movsbl (%rax), %eax
addl $-0x28, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x36, %eax
ja 0x7cb7
movq -0x18(%rbp), %rax
leaq 0x1342b(%rip), %rcx     # 0x1b004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, -0x1(%rbp)
jmp 0x7cbb
movb $0x1, -0x1(%rbp)
jmp 0x7cbb
movb $0x1, -0x1(%rbp)
jmp 0x7cbb
movb $0x1, -0x1(%rbp)
jmp 0x7cbb
movb $0x1, -0x1(%rbp)
jmp 0x7cbb
movb $0x1, -0x1(%rbp)
jmp 0x7cbb
movb $0x1, -0x1(%rbp)
jmp 0x7cbb
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x3720
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x7c3d
movb $0x1, -0x1(%rbp)
jmp 0x7cbb
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x3720
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x7c59
movb $0x1, -0x1(%rbp)
jmp 0x7cbb
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x3720
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0x7c75
movb $0x1, -0x1(%rbp)
jmp 0x7cbb
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x3720
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x7c91
movb $0x1, -0x1(%rbp)
jmp 0x7cbb
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x3720
movsbl (%rax), %eax
cmpl $0x5e, %eax
jne 0x7cad
movb $0x1, -0x1(%rbp)
jmp 0x7cbb
jmp 0x7caf
jmp 0x7cb1
jmp 0x7cb3
jmp 0x7cb5
jmp 0x7cb7
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: bothaynahazem[P]AsuMathLabG13/main.cpp
// Function: isLetter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool isLetter(string s)
{
    if (s[0]>='A' && s[0]<='Z')
        return true;
    else
        return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x3720
movsbl (%rax), %eax
cmpl $0x41, %eax
jl 0x7d0c
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3720
movsbl (%rax), %eax
cmpl $0x5a, %eax
jg 0x7d0c
movb $0x1, -0x1(%rbp)
jmp 0x7d10
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x3720
movsbl (%rax), %eax
addl $-0x28, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x36, %eax
ja 0x8862
movq -0x18(%rbp), %rax
leaq 0x12a4b(%rip), %rcx     # 0x1b1b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x8864
movl $0x1, -0x4(%rbp)
jmp 0x8864
movl $0x2, -0x4(%rbp)
jmp 0x8864
movl $0x2, -0x4(%rbp)
jmp 0x8864
movl $0x3, -0x4(%rbp)
jmp 0x8864
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8864
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x3720
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x87dc
movl $0x1, -0x4(%rbp)
jmp 0x8864
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x3720
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x87fb
movl $0x1, -0x4(%rbp)
jmp 0x8864
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x3720
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0x881a
movl $0x2, -0x4(%rbp)
jmp 0x8864
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x3720
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x8839
movl $0x2, -0x4(%rbp)
jmp 0x8864
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x3720
movsbl (%rax), %eax
cmpl $0x5e, %eax
jne 0x8858
movl $0x3, -0x4(%rbp)
jmp 0x8864
jmp 0x885a
jmp 0x885c
jmp 0x885e
jmp 0x8860
jmp 0x8862
ud2
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x18, %rdi
movq %rdi, -0x20(%rbp)
callq 0x3510
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdi
movl $0x0, 0x4(%rax)
movl $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
leaq 0xcde3(%rip), %rsi      # 0x1b400
callq 0x34f0
jmp 0xe624
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3270
movq -0x10(%rbp), %rdi
callq 0x3630
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x18, %rdi
leaq 0xcd56(%rip), %rsi      # 0x1b405
callq 0xafa0
testb $0x1, %al
jne 0xe6ba
jmp 0xe726
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xe709
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jge 0xe707
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xe6fa
movq -0x20(%rbp), %rdi
callq 0x34b0
jmp 0xe6fc
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xe6cc
jmp 0xe709
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xe724
movq -0x28(%rbp), %rdi
callq 0x34b0
jmp 0xe792
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe775
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl (%rcx), %eax
jge 0xe773
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xe766
movq -0x30(%rbp), %rdi
callq 0x34b0
jmp 0xe768
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xe738
jmp 0xe775
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xe790
movq -0x38(%rbp), %rdi
callq 0x34b0
jmp 0xe792
movq -0x18(%rbp), %rax
movl $0x0, 0x4(%rax)
movl $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x18, %rdi
movq %rdi, -0x30(%rbp)
callq 0x3510
movq -0x28(%rbp), %rdi
movl $0x0, 0x4(%rdi)
movl $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq -0x10(%rbp), %rsi
callq 0xecf0
jmp 0xecc1
addq $0x30, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3270
movq -0x18(%rbp), %rdi
callq 0x3630
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x18, %rdi
movq %rdi, -0x58(%rbp)
callq 0x3510
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rsi
movl $0x0, 0x4(%rax)
movl $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
leaq -0x30(%rbp), %rdi
callq 0x3180
jmp 0xf0c9
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xf120
jmp 0xf0d8
leaq -0x30(%rbp), %rdi
callq 0x3270
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xf10a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3270
movq -0x58(%rbp), %rdi
callq 0x3270
movq -0x38(%rbp), %rdi
callq 0x3630
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x18, %rdi
movq %rdi, -0x30(%rbp)
callq 0x3510
movq -0x28(%rbp), %rdi
movl $0x0, 0x4(%rdi)
movl $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movsd -0x10(%rbp), %xmm0
callq 0xf820
jmp 0xf7f3
addq $0x30, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3270
movq -0x18(%rbp), %rdi
callq 0x3630
nopw (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl $0x1, (%rdi)
movl $0x1, 0x4(%rdi)
addq $0x18, %rdi
leaq 0xbbb4(%rip), %rsi      # 0x1b405
callq 0xafa0
testb $0x1, %al
jne 0xf85f
jmp 0xf8f9
movl $0x8, %edi
callq 0x3030
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x10, %edi
callq 0x3030
movq %rax, -0x40(%rbp)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x38(%rbp)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x19810
jmp 0xf8a6
movq -0x38(%rbp), %rcx
movq -0x48(%rbp), %rax
addq $0x10, %rax
cmpq %rcx, %rax
movq %rax, -0x30(%rbp)
jne 0xf891
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rdx
movq 0x10(%rax), %rcx
movq %rdx, (%rcx)
movsd -0x10(%rbp), %xmm0
movq 0x10(%rax), %rax
movq (%rax), %rdi
callq 0x19840
jmp 0xf936
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x10, %esi
callq 0x36d0
jmp 0xf93c
movl $0x8, %edi
callq 0x3030
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x8, %edi
callq 0x3030
movq %rax, %rdx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rdx, (%rcx)
movsd -0x10(%rbp), %xmm0
movq 0x8(%rax), %rax
movq (%rax), %rax
movsd %xmm0, (%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3630
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x3640
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq 0xa7a4(%rip), %rsi      # 0x1b2da
callq 0xab40
jmp 0x10b3d
leaq -0x12(%rbp), %rdi
callq 0x3410
movl $0x0, -0x28(%rbp)
movq -0x78(%rbp), %rcx
movl -0x28(%rbp), %eax
cmpl (%rcx), %eax
jge 0x10c8a
movl $0x0, -0x2c(%rbp)
movq -0x78(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x10c46
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x32, %edx
callq 0x3220
movq -0x78(%rbp), %rcx
movl -0x2c(%rbp), %eax
movl 0x4(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x10be0
movq -0x78(%rbp), %rax
leaq -0x60(%rbp), %rdi
movq 0x8(%rax), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movl $0x32, %esi
leaq 0xa891(%rip), %rdx      # 0x1b44e
movb $0x1, %al
callq 0x3590
jmp 0x10c10
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x3410
jmp 0x10caa
movq -0x78(%rbp), %rax
leaq -0x60(%rbp), %rdi
movq 0x8(%rax), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movl $0x32, %esi
leaq 0xa849(%rip), %rdx      # 0x1b452
movb $0x1, %al
callq 0x3590
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x33a0
jmp 0x10c1f
jmp 0x10c21
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x10b63
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3270
jmp 0x10caa
movq -0x78(%rbp), %rcx
movl -0x28(%rbp), %eax
movl (%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x10c68
movq -0x70(%rbp), %rdi
movl $0x3b, %esi
callq 0x3290
jmp 0x10c66
jmp 0x10c7a
movq -0x70(%rbp), %rdi
movl $0x5d, %esi
callq 0x3290
jmp 0x10c78
jmp 0x10c7a
jmp 0x10c7c
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x10b4d
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x10c9d
movq -0x70(%rbp), %rdi
callq 0x3270
movq -0x80(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3630
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x3640
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq 0xa72c(%rip), %rsi      # 0x1b432
callq 0xab40
jmp 0x10d0d
leaq -0x12(%rbp), %rdi
callq 0x3410
movl $0x0, -0x28(%rbp)
movq -0x78(%rbp), %rcx
movl -0x28(%rbp), %eax
cmpl (%rcx), %eax
jge 0x10e48
movl $0x0, -0x2c(%rbp)
movq -0x78(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x10e16
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x32, %edx
callq 0x3220
movq -0x78(%rbp), %rcx
movl -0x2c(%rbp), %eax
movl 0x4(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x10db0
movq -0x78(%rbp), %rax
leaq -0x60(%rbp), %rdi
movq 0x8(%rax), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movl $0x32, %esi
leaq 0xa6c1(%rip), %rdx      # 0x1b44e
movb $0x1, %al
callq 0x3590
jmp 0x10de0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x3410
jmp 0x10e68
movq -0x78(%rbp), %rax
leaq -0x60(%rbp), %rdi
movq 0x8(%rax), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movl $0x32, %esi
leaq 0xa679(%rip), %rdx      # 0x1b452
movb $0x1, %al
callq 0x3590
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x33a0
jmp 0x10def
jmp 0x10df1
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x10d33
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3270
jmp 0x10e68
movq -0x78(%rbp), %rcx
movl -0x28(%rbp), %eax
movl (%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x10e38
movq -0x70(%rbp), %rdi
movl $0x3b, %esi
callq 0x3290
jmp 0x10e36
jmp 0x10e38
jmp 0x10e3a
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x10d1d
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x10e5b
movq -0x70(%rbp), %rdi
callq 0x3270
movq -0x80(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3630
nopw %cs:(%rax,%rax)
// File: bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::operator*=(std::complex<double>)
void Matrix::operator*=(complex<double> d)
{
	type="complex";
	for (int iR = 0;iR<nRows;iR++)
		for (int iC = 0;iC<nColumns;iC++)
			cvalues[iR][iC] *= d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x18, %rdi
leaq 0x8d4c(%rip), %rsi      # 0x1b405
callq 0x34f0
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl (%rcx), %eax
jge 0x1271f
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x12712
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movslq -0x20(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0x19b00
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x126d7
jmp 0x12714
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x126c5
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: bothaynahazem[P]AsuMathLabG13/Matrix2017.cpp
// Function: Matrix::operator/(Matrix&)
Matrix Matrix::operator/(Matrix& m) //C = A/B where C, A and B are all matrices
{
	Matrix r = *this;
	Matrix ret;
	ret = r.div(m);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xe0(%rbp)
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xec70
movq -0xe0(%rbp), %rdi
movb $0x0, -0x51(%rbp)
callq 0xe5d0
jmp 0x12857
movq -0x18(%rbp), %rdx
leaq -0xd8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x12930
jmp 0x1286d
movq -0xe0(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
leaq -0xd8(%rbp), %rdx
callq 0x10e80
jmp 0x12889
leaq -0xa0(%rbp), %rdi
callq 0xe650
leaq -0xd8(%rbp), %rdi
callq 0xe650
movb $0x1, -0x51(%rbp)
testb $0x1, -0x51(%rbp)
jne 0x128ef
jmp 0x128e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x12914
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x12908
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0xe650
jmp 0x12908
movq -0xe0(%rbp), %rdi
callq 0xe650
leaq -0x50(%rbp), %rdi
callq 0xe650
movq -0xe8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0xe0(%rbp), %rdi
callq 0xe650
leaq -0x50(%rbp), %rdi
callq 0xe650
movq -0x60(%rbp), %rdi
callq 0x3630
nopw %cs:(%rax,%rax)