LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/SimExec.cpp
// Function: SimExec::read_file(char*)
void SimExec::read_file( char *filename )
{
  FILE *fp;
  char name[512];
  char val[512];
  char line[512];
  int  num_syms = 0;


  if ((fp = fopen(filename, "r")) != NULL) 
  {

    while (!feof(fp)) 
    {

      fgets(line, 512, fp);

      if ((line[0] != '#') && !(isspace(line[0]))) 
      {
        get_args(line, name, val);

        parse_symbols(name, val);

        num_syms++;
      }
    }

    fclose(fp);
  }
  else 
  {
    printf("Nonfatal error opening file %s\n", filename);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x608, %rsp            # imm = 0x608
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x5213(%rip), %rsi      # 0x16f3a
movq %r15, %rdi
callq 0x31c0
testq %rax, %rax
je 0x11dc3
movq %rax, %r14
movq %rax, %rdi
callq 0x3270
testl %eax, %eax
jne 0x11da9
leaq -0x230(%rbp), %r15
leaq -0x630(%rbp), %r12
leaq -0x430(%rbp), %r13
movq %r15, %rdi
movl $0x200, %esi            # imm = 0x200
movq %r14, %rdx
callq 0x3290
movsbl -0x230(%rbp), %edi
cmpl $0x23, %edi
je 0x11d9d
callq 0x3050
testl %eax, %eax
jne 0x11d9d
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x110f6
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x11190
movq %r14, %rdi
callq 0x3270
testl %eax, %eax
je 0x11d5c
movq %r14, %rdi
callq 0x3180
addq $0x608, %rsp            # imm = 0x608
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4f28(%rip), %rdi      # 0x16cf2
movq %r15, %rsi
xorl %eax, %eax
addq $0x608, %rsp            # imm = 0x608
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3040
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/SimExec.cpp
// Function: SimExec::get_boolean(char*)
int SimExec::get_boolean(char *str)
{
  if ( (strcmp(str, "0\n") == 0) ||
    (strcmp(str, "0") == 0) ||
    (strcmp(str, "false\n") == 0) ||
    (strcmp(str, "false") == 0) )
    return 0;

  if ( (strcmp(str, "1\n") == 0) ||
    (strcmp(str, "1") == 0) ||
    (strcmp(str, "true\n") == 0) ||
    (strcmp(str, "true") == 0) )
    return 1;

  printf("Error in input to get_boolean() - %s, exiting\n", str);

  exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
leaq 0x5c67(%rip), %rsi      # 0x18124
movq %rbx, %rdi
callq 0x3220
xorl %r14d, %r14d
testl %eax, %eax
je 0x1255b
leaq 0x3e34(%rip), %rsi      # 0x1630b
movq %rbx, %rdi
callq 0x3220
testl %eax, %eax
je 0x1255b
leaq 0x5c3d(%rip), %rsi      # 0x18127
movq %rbx, %rdi
callq 0x3220
testl %eax, %eax
je 0x1255b
leaq 0x481a(%rip), %rsi      # 0x16d17
movq %rbx, %rdi
callq 0x3220
testl %eax, %eax
je 0x1255b
leaq 0x5c1e(%rip), %rsi      # 0x1812e
movq %rbx, %rdi
callq 0x3220
movl $0x1, %r14d
testl %eax, %eax
je 0x1255b
leaq 0x3ded(%rip), %rsi      # 0x16316
movq %rbx, %rdi
callq 0x3220
testl %eax, %eax
je 0x1255b
leaq 0x5bf5(%rip), %rsi      # 0x18131
movq %rbx, %rdi
callq 0x3220
testl %eax, %eax
je 0x1255b
leaq 0x47c3(%rip), %rsi      # 0x16d12
movq %rbx, %rdi
callq 0x3220
testl %eax, %eax
jne 0x12563
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x5bcd(%rip), %rdi      # 0x18137
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3040
xorl %edi, %edi
callq 0x31d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/SimExec.cpp
// Function: SimExec::get_list_index(char*, char**, int)
int SimExec::get_list_index( char *val,
                             char **list,
                             int  max_index )
{
  int index_found = 0;
  int index = 0;
  int i, tmpN;

  if (isdigit(val[0]))
    return atoi(val);

  tmpN=strlen(val);
  if (val[tmpN-1]=='\n')
    val[tmpN-1]='\0';

  if (val[tmpN-1]=='\r')
    val[tmpN-1]='\0';

  // TBD: Not sure why this works, but seems necessary for unix runs
  //  val[tmpN-1]='\0';
  //  val[tmpN-2]='\0';

  while (!index_found && (index<max_index))
  {
    //    if ((strcmp(val, list[index]) == 0) || (((strncmp(val, list[index],strlen(val)-2) == 0)) & (InWindows < 1)) )
    if ((strcmp(val, list[index]) == 0) )
      index_found = 1;
    else
      index++;
  }

  if (!index_found)
  {
    printf("Invalid mode in get_list_index: %s chosen from { ", val);

    for (i=0; i < max_index; i++)
      printf("%s ", list[i]);

    printf("}\n");
    printf("... exiting\n");

    exit(0);

  }
  else
  {

    return index;
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movsbl (%rsi), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x125ae
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3280
movl %ecx, %r14d
movq %rdx, %r12
movq %r15, %rdi
callq 0x30a0
decl %eax
cltq
cmpb $0xa, (%r15,%rax)
jne 0x125cc
movb $0x0, (%r15,%rax)
cmpb $0xd, (%r15,%rax)
jne 0x125d8
movb $0x0, (%r15,%rax)
testl %r14d, %r14d
jle 0x12615
xorl %eax, %eax
xorl %r13d, %r13d
movl %eax, %ebx
movl %eax, %eax
movq (%r12,%rax,8), %rsi
movq %r15, %rdi
callq 0x3220
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
movl $0x1, %ecx
cmovel %ecx, %r13d
setne %al
addl %ebx, %eax
testl %r13d, %r13d
sete %cl
jne 0x12619
cmpl %r14d, %eax
jl 0x125e2
jmp 0x12619
movb $0x1, %cl
xorl %eax, %eax
testb %cl, %cl
jne 0x1262c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5b33(%rip), %rdi      # 0x18166
movq %r15, %rsi
xorl %eax, %eax
callq 0x3040
testl %r14d, %r14d
jle 0x12668
movq %r12, %rbx
movl %r14d, %r15d
leaq 0x5b49(%rip), %r14      # 0x18198
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x3040
incq %r12
cmpq %r12, %r15
jne 0x12652
leaq 0x5e8c(%rip), %rdi      # 0x184fb
callq 0x3250
leaq 0x5e82(%rip), %rdi      # 0x184fd
callq 0x3250
xorl %edi, %edi
callq 0x31d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/Target.cpp
// Function: Target::Target()
Target::Target() :
MdlBase()
{
  //
  // Default initialization of input variables
  //
  frameTimeStep = 999.0e9;
  initFrameTime = 999.0e9;

//  initVxb = 1.0e3;
  initVxb = 270.0;
  weaveAmpl = 4.0 * GRAVITY;
  weavePeriod = 10;

  weaveStart = 999.e9;
  weaveEnd = -1.0;

  //
  // Register states for integration
  //
  RegisterState( pxf, vxf);
  RegisterState( pyf, vyf);

  RegisterState( vxf, axf);
  RegisterState( vyf, ayf);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xa084
leaq 0xaf87(%rip), %rax      # 0x1dc98
movq %rax, (%rbx)
movabsq $0x426d132148c00000, %rax # imm = 0x426D132148C00000
movq %rax, 0x8(%rbx)
movq %rax, 0xf8(%rbx)
movabsq $0x4070e00000000000, %rcx # imm = 0x4070E00000000000
movq %rcx, 0x100(%rbx)
movabsq $0x40439eb851eb851f, %rcx # imm = 0x40439EB851EB851F
movq %rcx, 0x118(%rbx)
movabsq $0x4024000000000000, %rcx # imm = 0x4024000000000000
movq %rcx, 0x120(%rbx)
movq %rax, 0x108(%rbx)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x110(%rbx)
leaq 0x160(%rbx), %rsi
leaq 0x180(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0xa376
leaq 0x168(%rbx), %rsi
leaq 0x190(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0xa376
leaq 0x130(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa376
leaq 0x140(%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa376
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xa1e4
movq %r14, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/Target.cpp
// Function: Target::Initialize()
void Target::Initialize()
{
  double cth;
  double sth;

  ResetAll();

  simTime = GetSimTime();
  
  nextFrameTime = initFrameTime;

  omega = TWOPI / weavePeriod;

  //
  // Crossing angle and flight path angle are supplements of each other.
  //
  theta = PI - pExec->xa;

  cth = cos( theta );
  sth = sin( theta );

  vxb = initVxb;
  vyb = 0.0;

  vxf = vxb * cth - vyb * sth;
  vyf = vxb * sth + vyb * cth;;

  pxf = -pExec->tFinal * vxf;
  pyf = -pExec->tFinal * vyf;

  weavePhase = uniform( -PI, PI, &pExec->seed );

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
movq %r14, 0x1a0(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x128(%rdi)
movups %xmm0, 0x138(%rdi)
movups %xmm0, 0x158(%rdi)
movups %xmm0, 0x168(%rdi)
movups %xmm0, 0x178(%rdi)
movups %xmm0, 0x188(%rdi)
movb $0x0, 0x198(%rdi)
movq 0x38(%rdi), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x1a0(%rdi)
movsd 0xf8(%rdi), %xmm0
movsd %xmm0, 0x30(%rdi)
movsd 0x5693(%rip), %xmm0     # 0x18518
divsd 0x120(%rdi), %xmm0
movsd %xmm0, 0x158(%rdi)
movq 0x1b0(%rdi), %rax
movsd 0x3cfc(%rip), %xmm0     # 0x16ba0
subsd 0x188(%rax), %xmm0
movsd %xmm0, 0x170(%rdi)
callq 0x3310
movsd %xmm0, -0x18(%rbp)
movsd 0x170(%rbx), %xmm0
callq 0x3080
movsd 0x100(%rbx), %xmm1
movsd %xmm1, 0x178(%rbx)
movq %r14, 0x188(%rbx)
movsd 0x5636(%rip), %xmm2     # 0x18520
mulsd %xmm0, %xmm2
movapd %xmm1, %xmm3
movsd -0x18(%rbp), %xmm4
mulsd %xmm4, %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, 0x180(%rbx)
xorpd %xmm2, %xmm2
mulsd %xmm4, %xmm2
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, 0x190(%rbx)
movq 0x1b0(%rbx), %rdi
movsd 0x178(%rdi), %xmm0
xorpd 0x30da(%rip), %xmm0     # 0x16010
mulsd %xmm0, %xmm3
movsd %xmm3, 0x160(%rbx)
mulsd %xmm1, %xmm0
movsd %xmm0, 0x168(%rbx)
addq $0x200, %rdi            # imm = 0x200
movsd 0x55cb(%rip), %xmm0     # 0x18528
movsd 0x3c3b(%rip), %xmm1     # 0x16ba0
callq 0x98c1
movsd %xmm0, 0x1a8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/Target.cpp
// Function: Target::Update()
void Target::Update()
{
  double tempAxf;
  double tempAyf;

  simTime = GetSimTime();
  
  if ( (simTime < weaveStart) || (simTime > weaveEnd) )
  {
    axb = 0.0;
    ayb = 0.0;
  }
  else
  {
    if ( !weaveInit )
    {
      weaveInit = true;

      vyf = -( weaveAmpl / omega ) * cos( weavePhase );

      pyf = -( weaveAmpl / SQ(omega) ) * sin( weavePhase );
    }

    tempAxf = 0.0;
    tempAyf = weaveAmpl * sin( simTime * omega + weavePhase );

    axb =  tempAxf * cos(theta) + tempAyf * sin(theta);
    ayb = -tempAxf * sin(theta) + tempAyf * cos(theta);

    jxf = 0.0;
    jyf = weaveAmpl * omega * cos( simTime * omega );
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x1a0(%rdi)
movsd 0x108(%rdi), %xmm1
ucomisd %xmm0, %xmm1
ja 0x13181
ucomisd 0x110(%rbx), %xmm0
ja 0x13181
cmpb $0x0, 0x198(%rbx)
jne 0x1309a
movb $0x1, 0x198(%rbx)
movsd 0x118(%rbx), %xmm0
xorpd 0x2fdc(%rip), %xmm0     # 0x16010
divsd 0x158(%rbx), %xmm0
movapd %xmm0, -0x20(%rbp)
movsd 0x1a8(%rbx), %xmm0
callq 0x3310
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x190(%rbx)
movsd 0x158(%rbx), %xmm0
mulsd %xmm0, %xmm0
movsd 0x118(%rbx), %xmm1
xorpd 0x2f99(%rip), %xmm1     # 0x16010
divsd %xmm0, %xmm1
movapd %xmm1, -0x20(%rbp)
movsd 0x1a8(%rbx), %xmm0
callq 0x3080
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x168(%rbx)
movsd 0x118(%rbx), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x1a0(%rbx), %xmm0
mulsd 0x158(%rbx), %xmm0
addsd 0x1a8(%rbx), %xmm0
callq 0x3080
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x170(%rbx), %xmm0
callq 0x3310
movsd %xmm0, -0x28(%rbp)
movsd 0x170(%rbx), %xmm0
callq 0x3080
mulsd -0x20(%rbp), %xmm0
xorpd %xmm1, %xmm1
mulsd -0x28(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x128(%rbx)
movsd 0x170(%rbx), %xmm0
callq 0x3080
movsd %xmm0, -0x28(%rbp)
movsd 0x170(%rbx), %xmm0
callq 0x3310
mulsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
mulsd 0x53e8(%rip), %xmm1     # 0x18520
addsd %xmm0, %xmm1
movsd %xmm1, 0x138(%rbx)
movq $0x0, 0x148(%rbx)
movsd 0x158(%rbx), %xmm0
movsd 0x118(%rbx), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, -0x20(%rbp)
mulsd 0x1a0(%rbx), %xmm0
callq 0x3310
mulsd -0x20(%rbp), %xmm0
movl $0x150, %eax            # imm = 0x150
jmp 0x13195
movq $0x0, 0x128(%rbx)
xorpd %xmm0, %xmm0
movl $0x138, %eax            # imm = 0x138
movsd %xmm0, (%rbx,%rax)
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/Target.cpp
// Function: Target::UpdateDerivatives()
void Target::UpdateDerivatives()
{
  simTime = GetSimTime();

  theta = atan2( vyf, vxf );

  axf = axb * cos(theta) - ayb * sin(theta);
  ayf = axb * sin(theta) + ayb * cos(theta);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x1a0(%rdi)
movsd 0x190(%rdi), %xmm0
movsd 0x180(%rdi), %xmm1
callq 0x3060
movsd %xmm0, 0x170(%rbx)
movsd 0x128(%rbx), %xmm1
movsd %xmm1, -0x20(%rbp)
callq 0x3310
movsd %xmm0, -0x18(%rbp)
movsd 0x138(%rbx), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x170(%rbx), %xmm0
callq 0x3080
mulsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
mulsd -0x20(%rbp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x130(%rbx)
movsd 0x128(%rbx), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x170(%rbx), %xmm0
callq 0x3080
movsd %xmm0, -0x18(%rbp)
movsd 0x138(%rbx), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x170(%rbx), %xmm0
callq 0x3310
mulsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
mulsd -0x20(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x140(%rbx)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::Construct(int, int, double)
void Matrix::Construct(int    _rows,
                       int    _cols,
                       double initVal)
{
  rows = _rows;
  cols = _cols;
  nElem = rows * cols;

  pData = new double[nElem];

  if (pData == NULL)
  {
    throw(MEMERR());
  }

  Set(initVal);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, -0x20(%rbp)
movl %edx, %ebx
movq %rdi, %r14
movl %esi, 0x8(%rdi)
movl %edx, (%rdi)
imull %esi, %ebx
movl %ebx, 0x4(%rdi)
movslq %ebx, %r15
leaq (,%r15,8), %rax
testl %r15d, %r15d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x3030
movsd -0x20(%rbp), %xmm0
movq %rax, 0x10(%r14)
testl %r15d, %r15d
jle 0x1356a
movl %ebx, %ecx
xorl %edx, %edx
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x1355d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::Matrix(Matrix const&)
Matrix::Matrix(const Matrix &mat)
{
  double *ptr1(mat.pData);
  double *ptr2(NULL);
  int _rows(mat.rows);
  int _cols(mat.cols);

  Construct(_rows, _cols);
  ptr2 = pData;

  for (int idx = 0; idx < nElem; ++idx)
  {
    *ptr2++ = *ptr1++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rsi), %r14
movl (%rsi), %r15d
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movl %r15d, (%rdi)
imull %eax, %r15d
movl %r15d, 0x4(%rdi)
movslq %r15d, %r12
leaq (,%r12,8), %rax
testl %r12d, %r12d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x3030
movq %rax, 0x10(%rbx)
testl %r12d, %r12d
jle 0x135da
movl %r15d, %ecx
xorl %edx, %edx
movsd (%r14,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpl %edx, %ecx
jne 0x135c8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::Construct(int, int)
void Matrix::Construct(int _rows,
                       int _cols)
{
  rows = _rows;
  cols = _cols;
  nElem = rows * cols;

  pData = new double[nElem];

  if (pData == NULL)
  {
    throw(MEMERR());
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, 0x8(%rdi)
movl %edx, (%rdi)
imull %esi, %edx
movl %edx, 0x4(%rdi)
movslq %edx, %rax
leaq (,%rax,8), %rcx
testl %eax, %eax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x3030
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::Resize(int, int, double)
void Matrix::Resize(int _rows, int _cols, double initVal)
{
  if (pData != NULL)
  {
    delete [] pData;
  }

  rows = _rows;
  cols = _cols;
  nElem = _rows * _cols;
  {
    Construct(rows, cols, initVal);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x13692
movsd %xmm0, -0x20(%rbp)
callq 0x3200
movsd -0x20(%rbp), %xmm0
movl %r14d, 0x8(%r15)
movl %ebx, (%r15)
movl %ebx, %eax
imull %r14d, %eax
movl %eax, 0x4(%r15)
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1350e
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::GetPtr(int, int)
bool Matrix::CheckDim(int row, int col)
{
  bool pass(false);

  if ((row >= 0) &&
      (row < rows) &&
      (col >=0 ) &&
      (col < cols))
  {
    pass = true;
  }

  return pass;
}

// Assembly:
testl %esi, %esi
js 0x13726
testl %edx, %edx
js 0x13726
cmpl %esi, 0x8(%rdi)
jle 0x13726
cmpl %edx, (%rdi)
jle 0x13726
movslq (%rdi), %rax
movslq %esi, %rcx
imulq %rax, %rcx
shlq $0x3, %rcx
addq 0x10(%rdi), %rcx
movl %edx, %eax
leaq (%rcx,%rax,8), %rax
retq
pushq %rbp
movq %rsp, %rbp
movl $0x8, %edi
callq 0x30b0
leaq 0xa60d(%rip), %rcx      # 0x1dd48
movq %rcx, (%rax)
leaq 0xa5ab(%rip), %rsi      # 0x1dcf0
movq 0xa894(%rip), %rdx      # 0x1dfe0
movq %rax, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::GetPtr(int)
bool Matrix::CheckDim(int idx)
{
  bool pass(false);

  if ((idx >= 0) &&
      (idx < nElem) &&
      ((rows == 1 ) ||
      (cols == 1)))
  {
    pass = true;
  }

  return pass;
}

// Assembly:
testl %esi, %esi
js 0x13773
cmpl %esi, 0x4(%rdi)
jle 0x13773
cmpl $0x1, 0x8(%rdi)
je 0x13768
cmpl $0x1, (%rdi)
jne 0x13773
movl %esi, %eax
shlq $0x3, %rax
addq 0x10(%rdi), %rax
retq
pushq %rbp
movq %rsp, %rbp
movl $0x8, %edi
callq 0x30b0
leaq 0xa5c0(%rip), %rcx      # 0x1dd48
movq %rcx, (%rax)
leaq 0xa55e(%rip), %rsi      # 0x1dcf0
movq 0xa847(%rip), %rdx      # 0x1dfe0
movq %rax, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::Print(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Matrix::Print(string format)
{
  double *pElem(pData);

  if (rows > 1)
  {
    for (int row = 0; row < rows; ++row)
    {
      for (int col = 0; col < cols; ++col)
      {
        printf(format.c_str(), *pElem);
        ++pElem;
      }
      printf("\n");
    }
  }
  else
  {
    for (int col = 0; col < cols; ++col)
    {
      printf(format.c_str(), *pElem);
      ++pElem;
    }
    printf("\n");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
cmpl $0x1, 0x8(%rdi)
jle 0x138b6
cmpl $0x0, 0x8(%r14)
jle 0x138a7
xorl %r12d, %r12d
cmpl $0x0, (%r14)
jle 0x13894
xorl %r13d, %r13d
movq (%rbx), %rdi
movsd (%r15), %xmm0
movb $0x1, %al
callq 0x3040
addq $0x8, %r15
incl %r13d
cmpl (%r14), %r13d
jl 0x13879
movl $0xa, %edi
callq 0x3210
incl %r12d
cmpl 0x8(%r14), %r12d
jl 0x13870
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x0, (%r14)
jle 0x138d7
xorl %r12d, %r12d
movq (%rbx), %rdi
movsd (%r15,%r12,8), %xmm0
movb $0x1, %al
callq 0x3040
incq %r12
cmpl (%r14), %r12d
jl 0x138bf
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3210
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::GetRow(int)
Matrix Matrix::GetRow(int row)
{
  if ((row < 0) ||
      (row >= rows))
  {
    throw(DIMERR());
  }

  Matrix result(1, cols);
  double *ptr1(pData + row * cols);
  double *ptr2(result.pData);

  for (int col = 0; col < cols; ++col)
  {
    *ptr2++ = *ptr1++;
  }
  
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %edx, %edx
js 0x139f8
movl %edx, %ebx
movq %rsi, %r15
cmpl %edx, 0x8(%rsi)
jle 0x139f8
movq %rdi, %r14
movl (%r15), %edx
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x1350e
movl (%r15), %eax
testl %eax, %eax
jle 0x139ea
movq 0x10(%r14), %rcx
imull %eax, %ebx
shlq $0x3, %rbx
addq 0x10(%r15), %rbx
xorl %edx, %edx
movsd (%rbx,%rdx,8), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
cmpl %edx, %eax
jne 0x139d9
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x30b0
leaq 0xa33f(%rip), %rcx      # 0x1dd48
movq %rcx, (%rax)
leaq 0xa2dd(%rip), %rsi      # 0x1dcf0
movq 0xa5c6(%rip), %rdx      # 0x1dfe0
movq %rax, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::GetCol(int)
Matrix Matrix::GetCol(int col)
{
  if ((col < 0) ||
      (col >= cols))
  {
    throw(DIMERR());
  }

  Matrix result(rows, 1);
  double *ptr1(pData + col);
  double *ptr2(result.pData);

  for (int row = 0; row < rows; ++row)
  {
    *ptr2++ = *ptr1;
    ptr1 += cols;
  }
  
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %edx, %edx
js 0x13a8f
movl %edx, %r15d
movq %rsi, %r14
cmpl %edx, (%rsi)
jle 0x13a8f
movq %rdi, %rbx
movl 0x8(%r14), %esi
xorps %xmm0, %xmm0
movl $0x1, %edx
callq 0x1350e
movl 0x8(%r14), %eax
testl %eax, %eax
jle 0x13a81
movl %r15d, %ecx
shlq $0x3, %rcx
addq 0x10(%r14), %rcx
movq 0x10(%rbx), %rdx
movslq (%r14), %rsi
shlq $0x3, %rsi
xorl %edi, %edi
movsd (%rcx), %xmm0
movsd %xmm0, (%rdx,%rdi,8)
incq %rdi
addq %rsi, %rcx
cmpl %edi, %eax
jne 0x13a6e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x30b0
leaq 0xa2a8(%rip), %rcx      # 0x1dd48
movq %rcx, (%rax)
leaq 0xa246(%rip), %rsi      # 0x1dcf0
movq 0xa52f(%rip), %rdx      # 0x1dfe0
movq %rax, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::operator[](int)
double* Matrix::operator[](int row)
{
  if ((row < 0) || (row > rows - 1))
  {
    throw(DIMERR());
  }

  double *pRow(pData + row * cols);

  return pRow;
}

// Assembly:
testl %esi, %esi
js 0x13b64
cmpl %esi, 0x8(%rdi)
jle 0x13b64
movslq (%rdi), %rcx
movslq %esi, %rax
imulq %rcx, %rax
shlq $0x3, %rax
addq 0x10(%rdi), %rax
retq
pushq %rbp
movq %rsp, %rbp
movl $0x8, %edi
callq 0x30b0
leaq 0xa1cf(%rip), %rcx      # 0x1dd48
movq %rcx, (%rax)
leaq 0xa16d(%rip), %rsi      # 0x1dcf0
movq 0xa456(%rip), %rdx      # 0x1dfe0
movq %rax, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::operator=(Matrix)
Matrix Matrix::operator= (Matrix mat)
{
  double *ptr1 = mat.pData;
  double *ptr2(NULL);
  int    _rows = mat.NumRows();
  int    _cols = mat.NumCols();

  Construct(_rows, _cols);
  ptr2 = pData;

  for (int idx = 0; idx < nElem; ++idx)
  {
    *ptr2++ = *ptr1++;
  }
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdx), %r15
movl (%rdx), %r12d
movl 0x8(%rdx), %eax
movl %eax, 0x8(%rsi)
movl %r12d, (%rsi)
imull %eax, %r12d
movl %r12d, 0x4(%rsi)
movslq %r12d, %r13
leaq (,%r13,8), %rax
testl %r13d, %r13d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x3030
movq %rax, 0x10(%r14)
testl %r13d, %r13d
jle 0x13bfc
movl %r12d, %ecx
xorl %edx, %edx
movsd (%r15,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpl %edx, %ecx
jne 0x13bea
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13576
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::operator+(Matrix) const
Matrix Matrix::operator+ (const Matrix rhs) const
{
  if ((rows != rhs.rows) ||
      (cols != rhs.cols))
  {
    throw(DIMERR()); 
  }

  Matrix result(rows, cols);

  for (int idx = 0; idx < nElem; ++idx)
  {
    result.pData[idx] = pData[idx] + rhs.pData[idx];
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movl 0x8(%rsi), %esi
cmpl 0x8(%rdx), %esi
jne 0x13cb0
movq %rdx, %r14
movl (%r15), %edx
cmpl (%r14), %edx
jne 0x13cb0
movq %rdi, %rbx
xorpd %xmm0, %xmm0
callq 0x1350e
movslq 0x4(%r15), %rax
testq %rax, %rax
jle 0x13ca2
movq 0x10(%r15), %rcx
movq 0x10(%r14), %rdx
movq 0x10(%rbx), %rsi
xorl %edi, %edi
movsd (%rcx,%rdi,8), %xmm0
addsd (%rdx,%rdi,8), %xmm0
movsd %xmm0, (%rsi,%rdi,8)
incq %rdi
cmpq %rdi, %rax
jne 0x13c8b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x30b0
leaq 0xa087(%rip), %rcx      # 0x1dd48
movq %rcx, (%rax)
leaq 0xa025(%rip), %rsi      # 0x1dcf0
movq 0xa30e(%rip), %rdx      # 0x1dfe0
movq %rax, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::operator/(Matrix) const
Matrix Matrix::operator/ (const Matrix rhs) const
{
  if ((rows != rhs.rows) ||
      (cols != rhs.cols))
  {
    throw(DIMERR()); 
  }

  Matrix result(rows, cols);

  for (int idx = 0; idx < nElem; ++idx)
  {
    if (rhs.pData[idx] == 0.0)
    {
      throw(DIVBYZERO());
    }

    result.pData[idx] = pData[idx] / rhs.pData[idx];
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movl 0x8(%rsi), %esi
cmpl 0x8(%rdx), %esi
jne 0x13e16
movq %rdx, %r15
movl (%r14), %edx
cmpl (%r15), %edx
jne 0x13e16
movq %rdi, %rbx
xorpd %xmm0, %xmm0
callq 0x1350e
xorpd %xmm2, %xmm2
movslq 0x4(%r14), %rax
testq %rax, %rax
jle 0x13dde
movq 0x10(%r15), %rcx
movq 0x10(%r14), %rdx
movq 0x10(%rbx), %rsi
xorl %edi, %edi
movsd (%rcx,%rdi,8), %xmm0
ucomisd %xmm2, %xmm0
jne 0x13dc8
jnp 0x13dec
movsd (%rdx,%rdi,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rsi,%rdi,8)
incq %rdi
cmpq %rdi, %rax
jne 0x13dbb
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x30b0
leaq 0x9f73(%rip), %rcx      # 0x1dd70
movq %rcx, (%rax)
leaq 0x9f01(%rip), %rsi      # 0x1dd08
movq 0xa1d2(%rip), %rdx      # 0x1dfe0
movq %rax, %rdi
callq 0x32b0
movl $0x8, %edi
callq 0x30b0
leaq 0x9f21(%rip), %rcx      # 0x1dd48
movq %rcx, (%rax)
leaq 0x9ebf(%rip), %rsi      # 0x1dcf0
movq 0xa1a8(%rip), %rdx      # 0x1dfe0
movq %rax, %rdi
callq 0x32b0
movq %rax, %r14
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x13e51
callq 0x3200
movq $0x0, 0x10(%rbx)
movq %r14, %rdi
callq 0x32d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::operator*(Matrix) const
Matrix Matrix::operator* (const Matrix rhs) const
{
  if (cols != rhs.rows)
  {
    throw(DIMERR()); 
  }

  Matrix result(rows, rhs.cols);

  double *pResElem(result.pData);
  double *pRhsCol(rhs.pData);
  double *pLhsRow(pData);

  for (int lhsRow = 0; lhsRow < rows; ++lhsRow)
  {
    for (int rhsCol = 0; rhsCol < rhs.cols; ++rhsCol)
    {
      pLhsRow = pData + lhsRow * cols;
      pRhsCol = rhs.pData + rhsCol;
      for (int resIdx = 0; resIdx < cols; ++resIdx)
      {
        *pResElem += *pLhsRow++ * *pRhsCol;
        pRhsCol += rhs.cols; 
      }
      ++pResElem;
    }
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl (%rsi), %eax
cmpl 0x8(%rdx), %eax
jne 0x13f1e
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rsi), %esi
movl (%rdx), %edx
xorpd %xmm0, %xmm0
callq 0x1350e
movslq 0x8(%r15), %rax
testq %rax, %rax
jle 0x13f0c
movq 0x10(%r14), %rcx
movl (%rbx), %edx
movq 0x10(%r15), %rsi
movl (%r15), %edi
movslq %edx, %r8
movslq %edi, %r9
shlq $0x3, %r9
shlq $0x3, %r8
xorl %r10d, %r10d
testl %edx, %edx
jle 0x13f01
movq 0x10(%rbx), %r11
xorl %r15d, %r15d
testl %edi, %edi
jle 0x13ef1
movsd (%rcx), %xmm0
movq %r11, %r12
xorl %r13d, %r13d
movsd (%rsi,%r13,8), %xmm1
mulsd (%r12), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rcx)
incq %r13
addq %r8, %r12
cmpl %r13d, %edi
jne 0x13ed2
addq $0x8, %rcx
incq %r15
addq $0x8, %r11
cmpq %rdx, %r15
jne 0x13ec4
incq %r10
addq %r9, %rsi
cmpq %rax, %r10
jne 0x13eb9
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x30b0
leaq 0x9e19(%rip), %rcx      # 0x1dd48
movq %rcx, (%rax)
leaq 0x9db7(%rip), %rsi      # 0x1dcf0
movq 0xa0a0(%rip), %rdx      # 0x1dfe0
movq %rax, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::operator+(double) const
Matrix Matrix::operator+ (const double rhs) const
{
  Matrix result(rows, cols);

  double *pResElem(result.pData);

  double *pElem(pData);

  for (int idx = 0; idx < nElem; ++idx)
  {
    *pResElem++ = *pElem++ + rhs;
  }

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, -0x18(%rbp)
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %edx
movl 0x8(%rsi), %esi
xorpd %xmm0, %xmm0
callq 0x1350e
movsd -0x18(%rbp), %xmm1
movl 0x4(%r14), %eax
testl %eax, %eax
jle 0x13f98
movq 0x10(%r14), %rcx
movq 0x10(%rbx), %rdx
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
cmpl %esi, %eax
jne 0x13f83
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::operator/(double) const
Matrix Matrix::operator/ (const double rhs) const
{
  if (rhs == 0.0)
  {
    throw(DIVBYZERO());
  }

  Matrix result(rows, cols);

  double *pResElem(result.pData);

  double *pElem(pData);

  for (int idx = 0; idx < nElem; ++idx)
  {
    *pResElem++ = *pElem++ / rhs;
  }

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
xorpd %xmm1, %xmm1
movsd %xmm0, -0x18(%rbp)
ucomisd %xmm1, %xmm0
jne 0x14078
jnp 0x140c4
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %edx
movl 0x8(%rsi), %esi
xorpd %xmm0, %xmm0
callq 0x1350e
movl 0x4(%r14), %eax
testl %eax, %eax
movsd -0x18(%rbp), %xmm1
jle 0x140b8
movq 0x10(%r14), %rcx
movq 0x10(%rbx), %rdx
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
cmpl %esi, %eax
jne 0x140a3
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x8, %edi
callq 0x30b0
leaq 0x9c9b(%rip), %rcx      # 0x1dd70
movq %rcx, (%rax)
leaq 0x9c29(%rip), %rsi      # 0x1dd08
movq 0x9efa(%rip), %rdx      # 0x1dfe0
movq %rax, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::operator+=(Matrix)
void Matrix::operator+= (const Matrix rhs)
{
  if ((rows != rhs.rows) ||
      (cols != rhs.cols))
  {
    throw(DIMERR()); 
  }

  double *pElem(pData);
  double *pRhsElem(rhs.pData); 

  for (int idx = 0; idx < nElem; ++idx)
  {
    *pElem++ += *pRhsElem++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jne 0x14129
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0x14129
movl 0x4(%rdi), %eax
testl %eax, %eax
jle 0x14127
movq 0x10(%rsi), %rcx
movq 0x10(%rdi), %rdx
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm0
addsd (%rdx,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
cmpl %esi, %eax
jne 0x14111
popq %rbp
retq
movl $0x8, %edi
callq 0x30b0
leaq 0x9c0e(%rip), %rcx      # 0x1dd48
movq %rcx, (%rax)
leaq 0x9bac(%rip), %rsi      # 0x1dcf0
movq 0x9e95(%rip), %rdx      # 0x1dfe0
movq %rax, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::operator*=(Matrix)
void Matrix::operator*= (const Matrix rhs)
{
  if ((rows != rhs.rows) ||
      (cols != rhs.cols))
  {
    throw(DIMERR()); 
  }

  double *pElem(pData);
  double *pRhsElem(rhs.pData); 
    if (*pRhsElem == 0.0)
    {
      throw(DIVBYZERO());
    }

  for (int idx = 0; idx < nElem; ++idx)
  {
    *pElem++ *= *pRhsElem++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jne 0x14205
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0x14205
movq 0x10(%rsi), %rax
movsd (%rax), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x141e0
jnp 0x14222
movl 0x4(%rdi), %ecx
testl %ecx, %ecx
jle 0x14203
movq 0x10(%rdi), %rdx
xorl %esi, %esi
movsd (%rax,%rsi,8), %xmm0
mulsd (%rdx,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
cmpl %esi, %ecx
jne 0x141ed
popq %rbp
retq
movl $0x8, %edi
callq 0x30b0
leaq 0x9b32(%rip), %rcx      # 0x1dd48
movq %rcx, (%rax)
leaq 0x9ad0(%rip), %rsi      # 0x1dcf0
jmp 0x1423d
movl $0x8, %edi
callq 0x30b0
leaq 0x9b3d(%rip), %rcx      # 0x1dd70
movq %rcx, (%rax)
leaq 0x9acb(%rip), %rsi      # 0x1dd08
movq 0x9d9c(%rip), %rdx      # 0x1dfe0
movq %rax, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::operator/=(double)
void Matrix::operator/= (const double rhs)
{
  if (rhs == 0.0)
  {
    throw(DIVBYZERO());
  }

  double *pElem(pData);

  for (int idx = 0; idx < nElem; ++idx)
  {
    *pElem++ /= rhs;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x14366
jnp 0x1438a
movl 0x4(%rdi), %eax
testl %eax, %eax
jle 0x14388
movq 0x10(%rdi), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rcx,%rdx,8)
incq %rdx
cmpl %edx, %eax
jne 0x14373
popq %rbp
retq
movl $0x8, %edi
callq 0x30b0
leaq 0x99d5(%rip), %rcx      # 0x1dd70
movq %rcx, (%rax)
leaq 0x9963(%rip), %rsi      # 0x1dd08
movq 0x9c34(%rip), %rdx      # 0x1dfe0
movq %rax, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::DotProduct(Matrix)
double Matrix::DotProduct(Matrix arg)
{
  double result(0.0);

  if ((arg.nElem != nElem) &&
      ((arg.rows != 1) || (arg.cols != 1)) &&
      ((rows != 1) || (cols != 1)))
  {
    throw (DIMERR());
  }

  for (int idx = 0; idx < nElem; ++idx)
  {
    result += pData[idx] * arg.pData[idx];
  }

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x4(%rdi), %eax
cmpl %eax, 0x4(%rsi)
je 0x14a22
cmpl $0x1, 0x8(%rsi)
jne 0x14a17
cmpl $0x1, (%rsi)
je 0x14a22
cmpl $0x1, 0x8(%rdi)
jne 0x14a52
cmpl $0x1, (%rdi)
jne 0x14a52
testl %eax, %eax
jle 0x14a4c
movq 0x10(%rdi), %rcx
movq 0x10(%rsi), %rdx
xorpd %xmm0, %xmm0
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm1
mulsd (%rdx,%rsi,8), %xmm1
addsd %xmm1, %xmm0
incq %rsi
cmpq %rsi, %rax
jne 0x14a34
jmp 0x14a50
xorpd %xmm0, %xmm0
popq %rbp
retq
movl $0x8, %edi
callq 0x30b0
leaq 0x92e5(%rip), %rcx      # 0x1dd48
movq %rcx, (%rax)
leaq 0x9283(%rip), %rsi      # 0x1dcf0
movq 0x956c(%rip), %rdx      # 0x1dfe0
movq %rax, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::Transpose()
Matrix Matrix::Transpose()
{
  Matrix result(cols, rows);

  for (int row = 0; row < rows; ++row)
  {
    for (int col = 0; col < cols; ++col)
    {
      result[col][row] = (*this)[row][col];
    }
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %esi
movl 0x8(%r14), %edx
xorps %xmm0, %xmm0
callq 0x1350e
cmpl $0x0, 0x8(%r14)
jle 0x14af5
xorl %r15d, %r15d
cmpl $0x0, (%r14)
jle 0x14ae9
xorl %r12d, %r12d
movq %r14, %rdi
movl %r15d, %esi
callq 0x13b48
movsd (%rax,%r12,8), %xmm0
movsd %xmm0, -0x28(%rbp)
movq %rbx, %rdi
movl %r12d, %esi
callq 0x13b48
movsd -0x28(%rbp), %xmm0
movsd %xmm0, (%rax,%r15,8)
incq %r12
movslq (%r14), %rax
cmpq %rax, %r12
jl 0x14ab2
incq %r15
movslq 0x8(%r14), %rax
cmpq %rax, %r15
jl 0x14aa9
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x14b16
callq 0x3200
movq $0x0, 0x10(%rbx)
movq %r14, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::IsSymmetric(double)
bool Matrix::IsSymmetric(double tol)
{
  int    col(0);
  bool   done(false);
  double eps(0.0);
  bool   result(true);
  int    row(0);

  std::numeric_limits<double> lim;

  eps = lim.min();

  if (tol == 0.0)
  {
    //
    // The default value of tol is 0.0, so no tolerance was provided.  Use
    // machine epsilon.
    //
    tol = eps;
  }

  if (rows != cols)
  {
    result = false;
  }
  else
  {
    while (!done)
    {
      if (row >= rows)
      {
        done = true;
      }

      while ((col <= row) && !done)
      {
        if (!WithinTolerance((*this)[row][col], (*this)[col][row], tol))
        {
          result = false;
          done = true;
        }
        ++col;
      }
      col = 0;
      ++row;
    }
  }
  return result;
}

// Assembly:
movl 0x8(%rdi), %ecx
xorl %eax, %eax
cmpl (%rdi), %ecx
jne 0x14c09
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
xorpd %xmm2, %xmm2
cmpeqsd %xmm0, %xmm2
movsd 0x3a58(%rip), %xmm1     # 0x185b0
andpd %xmm2, %xmm1
andnpd %xmm0, %xmm2
orpd %xmm1, %xmm2
movapd %xmm2, -0x40(%rbp)
movb $0x1, %r13b
xorl %r15d, %r15d
xorl %ebx, %ebx
movslq 0x8(%r14), %rax
cmpq %rax, %r15
movzbl %bl, %ebx
movl $0x1, %eax
cmovgel %eax, %ebx
testb $0x1, %bl
jne 0x14bec
xorl %r12d, %r12d
movq %r14, %rdi
movl %r15d, %esi
callq 0x13b48
movsd (%rax,%r12,8), %xmm0
movaps %xmm0, -0x50(%rbp)
movq %r14, %rdi
movl %r12d, %esi
callq 0x13b48
movapd -0x50(%rbp), %xmm1
subsd (%rax,%r15,8), %xmm1
andpd 0x19e2(%rip), %xmm1     # 0x165a0
movapd -0x40(%rbp), %xmm0
ucomisd %xmm1, %xmm0
movzbl %bl, %ebx
movl $0x1, %eax
cmovbl %eax, %ebx
movzbl %r13b, %r13d
movl $0x0, %eax
cmovbl %eax, %r13d
cmpq %r15, %r12
jae 0x14bec
incq %r12
testb $0x1, %bl
je 0x14b8b
incq %r15
testb $0x1, %bl
je 0x14b71
movl %r13d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::Minor(double, double)
double Matrix::Minor(double row_, double col_)
{
  int    minCol(0);
  Matrix minMat(rows-1, cols-1);
  double result(0);
  int    minRow(0);

  for (int row = 0; row < rows; ++row)
  {
    if (row != row_)
    {
      for (int col = 0; col < cols; ++col)
      {
        if  (col != col_)
        {
          minMat[minRow][minCol] = (*this)[row][col];
          ++minCol;
        }
      }
      ++minRow;
      minCol = 0;
    }
  }

  result = minMat.Det();

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movsd %xmm1, -0x58(%rbp)
movsd %xmm0, -0x50(%rbp)
movq %rdi, %rbx
movslq 0x8(%rdi), %rax
decq %rax
movslq (%rdi), %r14
decq %r14
movl %eax, -0x40(%rbp)
movl %r14d, -0x48(%rbp)
imulq %rax, %r14
movl %r14d, -0x44(%rbp)
movq %r14, %rax
shlq $0x3, %rax
testl %r14d, %r14d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x3030
movq %rax, -0x38(%rbp)
testl %r14d, %r14d
jle 0x14f0a
movl %r14d, %edx
shlq $0x3, %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x30e0
cmpl $0x0, 0x8(%rbx)
jle 0x14f8d
xorl %r14d, %r14d
xorl %r12d, %r12d
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
ucomisd -0x50(%rbp), %xmm0
jne 0x14f27
jnp 0x14f84
cmpl $0x0, (%rbx)
jle 0x14f81
xorl %r13d, %r13d
xorl %r15d, %r15d
xorps %xmm0, %xmm0
cvtsi2sd %r13d, %xmm0
ucomisd -0x58(%rbp), %xmm0
jne 0x14f43
jnp 0x14f76
movq %rbx, %rdi
movl %r14d, %esi
callq 0x13b48
movsd (%rax,%r13,8), %xmm0
movsd %xmm0, -0x30(%rbp)
leaq -0x48(%rbp), %rdi
movl %r12d, %esi
callq 0x13b48
movslq %r15d, %r15
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax,%r15,8)
incl %r15d
incq %r13
movslq (%rbx), %rax
cmpq %rax, %r13
jl 0x14f32
incl %r12d
incl %r14d
cmpl 0x8(%rbx), %r14d
jl 0x14f16
leaq -0x48(%rbp), %rdi
callq 0x14c4a
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x14fae
movsd %xmm0, -0x30(%rbp)
callq 0x3200
movsd -0x30(%rbp), %xmm0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14fbf
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x14fd0
callq 0x3200
movq %rbx, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::Eye(int)
void Matrix::Eye(int size)
{
  int idx(0);

  Resize(size, size);

  for (idx = 0; idx < rows; ++idx)
  {
    pData[idx * cols + idx] = 1.0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movl %esi, %edx
callq 0x13668
movslq 0x8(%rbx), %rax
testq %rax, %rax
jle 0x154c2
movq 0x10(%rbx), %rcx
movl (%rbx), %edx
incl %edx
xorl %esi, %esi
movabsq $0x3ff0000000000000, %rdi # imm = 0x3FF0000000000000
movslq %esi, %rsi
movq %rdi, (%rcx,%rsi,8)
addl %edx, %esi
decq %rax
jne 0x154b4
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: MATRIX::operator+(double, Matrix)
Matrix operator+ (const double lhs, Matrix rhs)
{
  Matrix result(rhs.NumRows(), rhs.NumCols());

  for (int row = 0; row < rhs.NumRows(); ++row)
  {
    for (int col = 0; col < rhs.NumCols(); ++col)
    {
      result[row][col] = lhs + rhs[row][col];
    }
  }

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movsd %xmm0, -0x28(%rbp)
movq %rdi, %rbx
movl (%rsi), %edx
movl 0x8(%rsi), %esi
xorpd %xmm0, %xmm0
callq 0x1350e
cmpl $0x0, 0x8(%r14)
jle 0x1557a
xorl %r15d, %r15d
cmpl $0x0, (%r14)
jle 0x15571
xorl %r12d, %r12d
movq %r14, %rdi
movl %r15d, %esi
callq 0x13b48
movsd (%rax,%r12,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x13b48
movsd -0x30(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, (%rax,%r12,8)
incq %r12
movslq (%r14), %rax
cmpq %rax, %r12
jl 0x15535
incl %r15d
cmpl 0x8(%r14), %r15d
jl 0x1552c
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1559b
callq 0x3200
movq $0x0, 0x10(%rbx)
movq %r14, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: MATRIX::operator/(double, Matrix)
Matrix operator/ (const double lhs, Matrix rhs)
{
  Matrix result(rhs.NumRows(), rhs.NumCols());

  for (int row = 0; row < rhs.NumRows(); ++row)
  {
    for (int col = 0; col < rhs.NumCols(); ++col)
    {
      if (rhs[row][col] == 0.0)
      {
        throw(Matrix::DIVBYZERO());
      }
      result[row][col] = lhs / rhs[row][col];
    }
  }

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movsd %xmm0, -0x28(%rbp)
movq %rdi, %rbx
movl (%rsi), %edx
movl 0x8(%rsi), %esi
xorpd %xmm0, %xmm0
callq 0x1350e
cmpl $0x0, 0x8(%r14)
jle 0x157aa
xorl %r15d, %r15d
cmpl $0x0, (%r14)
jle 0x157a1
xorl %r12d, %r12d
movq %r14, %rdi
movl %r15d, %esi
callq 0x13b48
movsd (%rax,%r12,8), %xmm0
ucomisd 0xe67(%rip), %xmm0      # 0x165c8
jne 0x15765
jnp 0x157ba
movq %r14, %rdi
movl %r15d, %esi
callq 0x13b48
movsd (%rax,%r12,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x13b48
movsd -0x28(%rbp), %xmm0
divsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax,%r12,8)
incq %r12
movslq (%r14), %rax
cmpq %rax, %r12
jl 0x15748
incl %r15d
cmpl 0x8(%r14), %r15d
jl 0x1573f
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x30b0
leaq 0x85a5(%rip), %rcx      # 0x1dd70
movq %rcx, (%rax)
leaq 0x8533(%rip), %rsi      # 0x1dd08
movq 0x8804(%rip), %rdx      # 0x1dfe0
movq %rax, %rdi
callq 0x32b0
jmp 0x157e6
movq %rax, %r14
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x157f7
callq 0x3200
movq $0x0, 0x10(%rbx)
movq %r14, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/test/units/redirect/redirect_srv.c
// Function: main
int main(int argc, char *argv[])
{
  scdc_init(SCDC_INIT_DEFAULT);

  TRACE_F("dataprov open");
  scdc_dataprov_t dp = scdc_dataprov_open(REDIRECT_TEST_SCDC_PATH, "hook", &redirect_test_hook);

  TRACE_F("nodeport open");
  scdc_nodeport_t np = scdc_nodeport_open("uds:socketname:max_connections", "redirect", 2);
/*  scdc_nodeport_t np = scdc_nodeport_open("tcp:max_connections", 2);*/

  TRACE_F("nodeport start");
  scdc_nodeport_start(np, SCDC_NODEPORT_START_ASYNC_UNTIL_CANCEL);

  printf(TRACE_PREFIX "Press <ENTER> to quit!\n");
  getchar();

  TRACE_F("nodeport stop");
  scdc_nodeport_stop(np);

  TRACE_F("nodeport close");
  scdc_nodeport_close(np);

  TRACE_F("dataprov close");
  scdc_dataprov_close(dp);

  scdc_release();

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x5d9b1(%rip), %rdi     # 0x6a4ad
xorl %eax, %eax
callq 0x18351
movq 0x7e496(%rip), %r13     # 0x8afa0
movq (%r13), %rdi
leaq 0x5b4ef(%rip), %rbx     # 0x68004
leaq 0x5b4fb(%rip), %r14     # 0x68017
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0xb7b0
movq (%r13), %rcx
leaq 0x5b4e8(%rip), %rdi     # 0x6801c
movl $0xd, %esi
movl $0x1, %edx
callq 0xbab0
movq (%r13), %rsi
movl $0xa, %edi
callq 0xb690
leaq 0x5b4d2(%rip), %r12     # 0x6802a
leaq 0x5ecd9(%rip), %rsi     # 0x6b838
leaq 0x7c002(%rip), %rdx     # 0x88b68
movq %r12, %rdi
xorl %eax, %eax
callq 0x18713
movq %rax, %r15
movq (%r13), %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0xb7b0
movq (%r13), %rcx
leaq 0x5b4a4(%rip), %rdi     # 0x68033
movl $0xd, %esi
movl $0x1, %edx
callq 0xbab0
movq (%r13), %rsi
movl $0xa, %edi
callq 0xb690
leaq 0x5b48e(%rip), %rdi     # 0x68041
movq %r12, %rsi
movl $0x2, %edx
xorl %eax, %eax
callq 0x18918
movq %rax, %r12
movq (%r13), %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0xb7b0
movq (%r13), %rcx
leaq 0x5b47f(%rip), %rdi     # 0x68060
movl $0xe, %esi
movl $0x1, %edx
callq 0xbab0
movq (%r13), %rsi
movl $0xa, %edi
callq 0xb690
movl $0x4, %esi
movq %r12, %rdi
callq 0x18a2c
leaq 0x5b489(%rip), %rdi     # 0x6809b
callq 0xb880
callq 0xb760
movq (%r13), %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0xb7b0
movq (%r13), %rcx
leaq 0x5b437(%rip), %rdi     # 0x6806f
movl $0xd, %esi
movl $0x1, %edx
callq 0xbab0
movq (%r13), %rsi
movl $0xa, %edi
callq 0xb690
movq %r12, %rdi
callq 0x18a5d
movq (%r13), %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0xb7b0
movq (%r13), %rcx
leaq 0x5b404(%rip), %rdi     # 0x6807d
movl $0xe, %esi
movl $0x1, %edx
callq 0xbab0
movq (%r13), %rsi
movl $0xa, %edi
callq 0xb690
movq %r12, %rdi
callq 0x18a0a
movq (%r13), %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0xb7b0
movq (%r13), %rcx
leaq 0x5b3d2(%rip), %rdi     # 0x6808c
movl $0xe, %esi
movl $0x1, %edx
callq 0xbab0
movq (%r13), %rsi
movl $0xa, %edi
callq 0xb690
movq %r15, %rdi
callq 0x1880e
callq 0x18456
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq