LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]fase/DynamicGraph.cpp
// Function: DynamicGraph::_deleteAux()
void DynamicGraph::_deleteAux() {
  int i;

  if (_adjM != NULL) {
    for (i = 0; i < _num_nodes; i++)
      if (_adjM[i] != NULL)
        delete[] _adjM[i];
    delete[] _adjM;
  }

  if (_hashM != NULL) {
    int j;
    for (i = 0; i < _num_nodes; i++) {
      if (_hash_out != NULL) {
        for (j = 0; j < _hash_out[i]; j++) {
          l_list* cur = _hashM[i][j], *prev;
          while (cur != NULL) {
            prev = cur;
            cur = cur->next;
            delete prev;
          }
        }
      }
   
      delete[] _hashM[i];
    }
    delete[] _hashM;
  }

  if (hybrid_ch != NULL) delete[] hybrid_ch;

  ready = false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x48(%rdi)
je 0x494e
xorl %r14d, %r14d
movslq 0xc(%rbx), %rax
movq 0x48(%rbx), %rdi
cmpq %rax, %r14
jge 0x4944
movq (%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x493f
callq 0x2230
incq %r14
jmp 0x4924
testq %rdi, %rdi
je 0x494e
callq 0x2230
cmpq $0x0, 0x70(%rbx)
je 0x49ca
xorl %r15d, %r15d
pushq $0x10
popq %r14
movslq 0xc(%rbx), %rax
cmpq %rax, %r15
jge 0x49bc
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x49a5
xorl %r12d, %r12d
movslq (%rax,%r15,4), %rax
cmpq %rax, %r12
jge 0x49a5
movq 0x70(%rbx), %rax
movq (%rax,%r15,8), %rax
movq (%rax,%r12,8), %rdi
testq %rdi, %rdi
je 0x499c
movq 0x8(%rdi), %r13
movq %r14, %rsi
callq 0x21b0
movq %r13, %rdi
jmp 0x4986
incq %r12
movq 0x30(%rbx), %rax
jmp 0x4971
movq 0x70(%rbx), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x49b7
callq 0x2230
incq %r15
jmp 0x495c
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x49ca
callq 0x2230
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x49d8
callq 0x2230
movb $0x0, 0x78(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]fase/DynamicGraph.cpp
// Function: DynamicGraph::zero()
void DynamicGraph::zero() {
  int i,j;
  _num_edges = 0;
  ready = false;

  for (i = 0; i < _num_nodes; i++) {
    _in[i] = 0;
    _out[i] = 0;
    _hash_out[i] = 0;
    _num_neighbours[i] = 0;

    _adjIn[i].clear();
    _adjOut[i].clear();
    _neighbours[i].clear();
  }
}

// Assembly:
pushq %r14
pushq %rbx
andl $0x0, 0x10(%rdi)
movb $0x0, 0x78(%rdi)
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rcx
movq 0x30(%rdi), %rdx
movq 0x38(%rdi), %rsi
movq 0x60(%rdi), %r8
movq 0x58(%rdi), %r9
movq 0x68(%rdi), %r10
movabsq $0x2, %r11
xorl %ebx, %ebx
movslq 0xc(%rdi), %r14
cmpq %r14, %rbx
jge 0x4a68
andl $0x0, (%rax,%rbx,4)
andl $0x0, (%rcx,%rbx,4)
andl $0x0, (%rdx,%rbx,4)
andl $0x0, (%rsi,%rbx,4)
movq -0x8(%r8,%r11,4), %r14
cmpq %r14, (%r8,%r11,4)
je 0x4a41
movq %r14, (%r8,%r11,4)
movq -0x8(%r9,%r11,4), %r14
cmpq %r14, (%r9,%r11,4)
je 0x4a50
movq %r14, (%r9,%r11,4)
movq -0x8(%r10,%r11,4), %r14
cmpq %r14, (%r10,%r11,4)
je 0x4a5f
movq %r14, (%r10,%r11,4)
incq %rbx
addq $0x6, %r11
jmp 0x4a19
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]fase/DynamicGraph.cpp
// Function: DynamicGraph::createGraph(int, GraphType)
void DynamicGraph::createGraph(int n, GraphType t) {
  _delete();
  
  int i;
  _num_nodes = n;
  _type = t;
  
  int tmp_log = 4 * (int)log2((double) n);
  _log_nodes = 1;
  while (_log_nodes < tmp_log)
    _log_nodes *= 2;
  _log_nodes--;
  
  _adjIn      = new vector<int>[n];
  _adjOut     = new vector<int>[n];
  _neighbours = new vector<int>[n];

  _in             = new int[n];
  _out            = new int[n];
  _num_neighbours = new int[n];
  _hash_out       = new int[n];

  zero();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
callq 0x46fa
movl %ebp, 0xc(%rbx)
movl %r14d, 0x8(%rbx)
cvtsi2sd %ebp, %xmm0
callq 0x2300
cvttsd2si %xmm0, %eax
shll $0x2, %eax
pushq $0x1
popq %rdx
movl %edx, %ecx
leal (%rcx,%rcx), %edx
cmpl %eax, %ecx
jl 0x4a9e
movslq %ebp, %r14
pushq $0x18
popq %r13
movq %r14, %rax
mulq %r13
movq %rax, %r15
seto %al
addq $0x8, %r15
pushq $-0x1
popq %rdx
cmovbq %rdx, %r15
testb %al, %al
cmovneq %rdx, %r15
decl %ecx
movl %ecx, 0x18(%rbx)
movq %r15, %rdi
callq 0x2030
movq %rax, %r12
movq %r14, (%rax)
addq $0x8, %r12
testl %ebp, %ebp
je 0x4b0a
imulq $0x18, %r14, %rcx
addq $-0x18, %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %r13
subq %rdx, %rcx
addq $0x18, %rcx
movq %r12, %rdi
xorl %esi, %esi
movq %rcx, %rdx
callq 0x20e0
movq %r12, 0x60(%rbx)
movq %r15, %rdi
callq 0x2030
leaq 0x8(%rax), %r12
movq %r14, (%rax)
testl %ebp, %ebp
je 0x4b45
imulq $0x18, %r14, %rcx
addq $-0x18, %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %r13
subq %rdx, %rcx
addq $0x18, %rcx
movq %r12, %rdi
xorl %esi, %esi
movq %rcx, %rdx
callq 0x20e0
movq %r12, 0x58(%rbx)
movq %r15, %rdi
callq 0x2030
leaq 0x8(%rax), %r15
movq %r14, (%rax)
testl %ebp, %ebp
je 0x4b80
imulq $0x18, %r14, %rcx
addq $-0x18, %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %r13
subq %rdx, %rcx
addq $0x18, %rcx
movq %r15, %rdi
xorl %esi, %esi
movq %rcx, %rdx
callq 0x20e0
movq %r15, 0x68(%rbx)
shlq $0x2, %r14
testl %ebp, %ebp
pushq $-0x1
popq %rax
cmovsq %rax, %r14
movq %r14, %rdi
callq 0x2030
movq %rax, 0x20(%rbx)
movq %r14, %rdi
callq 0x2030
movq %rax, 0x28(%rbx)
movq %r14, %rdi
callq 0x2030
movq %rax, 0x38(%rbx)
movq %r14, %rdi
callq 0x2030
movq %rax, 0x30(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *0x20(%rax)
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]fase/DynamicGraph.cpp
// Function: DynamicGraph::addEdge(int, int)
void DynamicGraph::addEdge(int a, int b) {
  _adjOut[a].push_back(b);
  _out[a]++;

  _adjIn[b].push_back(a);
  _in[b]++;

  _num_edges++;

  if (!hasEdge(b, a)) {
    _neighbours[b].push_back(a);
    _num_neighbours[b]++;

    _neighbours[a].push_back(b);
    _num_neighbours[a]++;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
movl %esi, (%r14)
movq %rsp, %r15
movl %edx, (%r15)
movslq %esi, %r12
imulq $0x18, %r12, %rdi
addq 0x58(%rbx), %rdi
movq %r15, %rsi
callq 0x5328
movq 0x28(%rbx), %rax
incl (%rax,%r12,4)
movslq (%r15), %rax
imulq $0x18, %rax, %rdi
addq 0x60(%rbx), %rdi
movq %r14, %rsi
callq 0x5328
movq 0x20(%rbx), %rax
movslq (%r15), %rcx
incl (%rax,%rcx,4)
incl 0x10(%rbx)
movl (%r15), %esi
movl (%r14), %edx
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x48(%rax)
testb %al, %al
jne 0x4fab
movq %rsp, %r14
movslq (%r14), %rax
imulq $0x18, %rax, %rdi
addq 0x68(%rbx), %rdi
leaq 0x4(%rsp), %r15
movq %r15, %rsi
callq 0x5328
movq 0x38(%rbx), %rax
movslq (%r14), %rcx
incl (%rax,%rcx,4)
movslq (%r15), %rax
imulq $0x18, %rax, %rdi
addq 0x68(%rbx), %rdi
movq %r14, %rsi
callq 0x5328
movq 0x38(%rbx), %rax
movslq (%r15), %rcx
incl (%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]fase/DynamicGraph.cpp
// Function: DynamicGraph::rmEdge(int, int)
void DynamicGraph::rmEdge(int a, int b) {
  ready = false;

  if (!hasEdge(a, b)) return;

  _removeVector(_adjOut[a], b);
  _out[a]--;

  _removeVector(_adjIn[b], a);
  _in[b]--;

  _num_edges--;

  if (!hasEdge(b, a)) {
    _removeVector(_neighbours[a], b);
    _num_neighbours[a]--;
    _removeVector(_neighbours[b], a);
    _num_neighbours[b]--;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
movb $0x0, 0x78(%rdi)
movq (%rdi), %rax
callq *0x48(%rax)
testb %al, %al
je 0x5061
movslq %ebp, %r12
imulq $0x18, %r12, %r15
movq 0x58(%rbx), %rsi
addq %r15, %rsi
movl %r14d, %edx
callq 0x5070
movq 0x28(%rbx), %rax
movq %r12, (%rsp)
decl (%rax,%r12,4)
movslq %r14d, %r13
imulq $0x18, %r13, %r12
movq 0x60(%rbx), %rsi
addq %r12, %rsi
movl %ebp, %edx
callq 0x5070
movq 0x20(%rbx), %rax
decl (%rax,%r13,4)
decl 0x10(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq *0x48(%rax)
testb %al, %al
jne 0x5061
addq 0x68(%rbx), %r15
movq %r15, %rsi
movl %r14d, %edx
callq 0x5070
movq 0x38(%rbx), %rax
movq (%rsp), %rcx
decl (%rax,%rcx,4)
addq 0x68(%rbx), %r12
movq %r12, %rsi
movl %ebp, %edx
callq 0x5070
movq 0x38(%rbx), %rax
decl (%rax,%r13,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]fase/DynamicGraph.cpp
// Function: DynamicGraph::hasEdge(int, int)
bool DynamicGraph::hasEdge(int a, int b) {
  if (!ready) {
    int i;
    for (i = 0; i < _out[a]; i++)
      if (_adjOut[a][i] == b)
        return true;
    return false;
  }

  if (!hybrid_ch[a])
    return _adjM[a][b];
  else if (_out[a] < 3) {
    int i;
    for (i = 0; i < _out[a]; i++)
      if (_adjOut[a][i] == b)
        return true;

    return false;
  }
  else {
    l_list* cur = _hashM[a][b & _hash_out[a]];
    while (cur != NULL) {
      if (cur->value == b)
        return true;

      cur = cur->next;
    }
    return false;
  }

  return false;
}

// Assembly:
cmpb $0x0, 0x78(%rdi)
je 0x50f0
movq 0x40(%rdi), %rcx
movslq %esi, %rax
cmpl $0x0, (%rcx,%rax,4)
je 0x5123
movq 0x28(%rdi), %rcx
movl (%rcx,%rax,4), %ecx
cmpl $0x2, %ecx
jg 0x5132
imulq $0x18, %rax, %rsi
addq 0x58(%rdi), %rsi
xorl %edi, %edi
testl %ecx, %ecx
cmovlel %edi, %ecx
cmpq %rdi, %rcx
setne %al
je 0x515d
movq (%rsi), %r8
leaq 0x1(%rdi), %r9
cmpl %edx, (%r8,%rdi,4)
movq %r9, %rdi
jne 0x50d6
jmp 0x515d
movq 0x28(%rdi), %rax
movslq %esi, %rsi
movl (%rax,%rsi,4), %ecx
imulq $0x18, %rsi, %rsi
addq 0x58(%rdi), %rsi
xorl %edi, %edi
testl %ecx, %ecx
cmovlel %edi, %ecx
cmpq %rdi, %rcx
setne %al
je 0x515d
movq (%rsi), %r8
leaq 0x1(%rdi), %r9
cmpl %edx, (%r8,%rdi,4)
movq %r9, %rdi
jne 0x5109
jmp 0x515d
movq 0x48(%rdi), %rcx
movq (%rcx,%rax,8), %rax
movslq %edx, %rcx
movb (%rax,%rcx), %al
retq
movq 0x30(%rdi), %rcx
movq 0x70(%rdi), %rsi
movl (%rcx,%rax,4), %ecx
andl %edx, %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq (%rsi,%rax,8), %rcx
movq (%rcx), %rsi
testq %rsi, %rsi
setne %al
je 0x515d
leaq 0x8(%rsi), %rcx
cmpl %edx, (%rsi)
jne 0x514a
retq
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]fase/DynamicGraph.cpp
// Function: DynamicGraph::makeArrayNeighbours()
void DynamicGraph::makeArrayNeighbours() {
  int i,j;
  vector<int>:: iterator ii;
  _array_neighbours = new int*[_num_nodes];  
  for (i = 0; i < _num_nodes; i++) {
    _array_neighbours[i] = new int[_neighbours[i].size()];
    for (ii = _neighbours[i].begin(), j = 0; ii != _neighbours[i].end(); ii++, j++)
      _array_neighbours[i][j] = *ii;
    _neighbours[i].clear();
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movslq 0xc(%rdi), %r13
leaq (,%r13,8), %rdi
testq %r13, %r13
pushq $-0x1
popq %r15
cmovsq %r15, %rdi
callq 0x2030
movq %rax, %r14
movq %rax, 0x50(%rbx)
xorl %r12d, %r12d
movslq %r13d, %rax
cmpq %rax, %r12
jge 0x5280
movq 0x68(%rbx), %rax
imulq $0x18, %r12, %r13
movq 0x8(%rax,%r13), %rdi
subq (%rax,%r13), %rdi
cmovsq %r15, %rdi
callq 0x2030
movq %rax, (%r14,%r12,8)
movq 0x50(%rbx), %r14
movq 0x68(%rbx), %rdx
leaq (%rdx,%r13), %rax
movq (%rdx,%r13), %rcx
movq 0x8(%rdx,%r13), %rdx
xorl %esi, %esi
leaq (%rcx,%rsi), %rdi
cmpq %rdx, %rdi
je 0x526e
movl (%rdi), %edi
movq (%r14,%r12,8), %r8
movl %edi, (%r8,%rsi)
addq $0x4, %rsi
jmp 0x5255
cmpq %rcx, %rdx
je 0x5277
movq %rcx, 0x8(%rax)
incq %r12
movl 0xc(%rbx), %r13d
jmp 0x5218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]fase/DynamicGraph.cpp
// Function: DynamicGraph::makeVectorNeighbours()
void DynamicGraph::makeVectorNeighbours() {
  int i,j;
  vector<int>:: iterator ii;

  for (i = 0; i < _num_nodes; i++)
    for (j = 0; j < _num_neighbours[i]; j++)
      _neighbours[i].push_back(_array_neighbours[i][j]);

  if (_array_neighbours!=NULL) {
    for (i = 0; i < _num_nodes; i++)
      if (_array_neighbours[i] != NULL)
        delete[] _array_neighbours[i];
    delete[] _array_neighbours;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movslq 0xc(%rbx), %rax
cmpq %rax, %r14
jge 0x52de
imulq $0x18, %r14, %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x38(%rbx), %rax
movslq (%rax,%r14,4), %rax
cmpq %rax, %r13
jge 0x52d9
movq 0x68(%rbx), %rdi
addq %r15, %rdi
movq 0x50(%rbx), %rax
movq (%rax,%r14,8), %rsi
addq %r12, %rsi
callq 0x5328
incq %r13
addq $0x4, %r12
jmp 0x52ac
incq %r14
jmp 0x5299
cmpq $0x0, 0x50(%rbx)
je 0x531d
xorl %r14d, %r14d
movslq %eax, %rcx
movq 0x50(%rbx), %rdi
cmpq %rcx, %r14
jge 0x530a
movq (%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x5305
callq 0x2230
movl 0xc(%rbx), %eax
incq %r14
jmp 0x52e8
testq %rdi, %rdi
je 0x531d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2230
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]fase/FaseMain.cpp
// Function: initSamplingProbabilities(Fase*)
void initSamplingProbabilities(Fase* fase)
{
  int i;
  prob = 1.0;
  for (i = 0; i < K; i++)
    prob *= sampProb[i];

  if (samp && fabs(prob) > 10e-7)
    fase->initSampling(K, sampProb);
  else
    prob = 1.0;
}

// Assembly:
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movl 0x7fc5(%rip), %esi      # 0x135b0
xorl %ecx, %ecx
testl %esi, %esi
movl $0x0, %edx
cmovgl %esi, %edx
movq %rax, 0x8062(%rip)      # 0x13660
shlq $0x3, %rdx
movsd 0x176e(%rip), %xmm0     # 0xcd78
leaq 0x7faf(%rip), %r8       # 0x135c0
cmpq %rcx, %rdx
je 0xb62a
mulsd (%rcx,%r8), %xmm0
movsd %xmm0, 0x803c(%rip)     # 0x13660
addq $0x8, %rcx
jmp 0xb611
cmpb $0x1, 0x803a(%rip)      # 0x1366b
jne 0xb651
andpd 0x1765(%rip), %xmm0     # 0xcda0
ucomisd 0x173d(%rip), %xmm0     # 0xcd80
jbe 0xb651
leaq 0x7f74(%rip), %rdx      # 0x135c0
jmp 0x2760
movq %rax, 0x8008(%rip)      # 0x13660
retq
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]fase/FaseMain.cpp
// Function: main
int main(int argc, char **argv)
{
  init();
  read(argc, argv);

  if (K <= 2 || K >= MAXMOTIF)
  {
    fprintf(stderr, "Subgraph size needs to be between 3 and %d...\n", MAXMOTIF - 1);
    return 1;
  }

  Random::init(time(NULL));
  Fase* fase = new Fase(G, dir);
  initSamplingProbabilities(fase);

  Timer::start();
  fase->runCensus(K);
  Timer::stop();

  output(fase);
  finish(fase);
  
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
callq 0xb15c
movl %ebp, %edi
movq %rbx, %rsi
callq 0xb185
movl 0x7b3e(%rip), %eax      # 0x135b0
addl $-0x14, %eax
cmpl $-0x12, %eax
jbe 0xbae4
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x2160
movl %eax, %edi
callq 0x6e88
movl $0x3c8, %edi            # imm = 0x3C8
callq 0x21a0
movq %rax, %r14
movq 0x7b0a(%rip), %rsi      # 0x135a8
movzbl 0x7bc3(%rip), %edx      # 0x13668
movq %rax, %rdi
callq 0x25cc
movq %r14, %rdi
callq 0xb5db
callq 0x464c
movl 0x7af0(%rip), %esi      # 0x135b0
movq %r14, %rdi
callq 0x2788
callq 0x465a
movq %r14, %rdi
callq 0xb659
movq %r14, %rdi
callq 0xba17
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x74e5(%rip), %rax      # 0x12fd0
movq (%rax), %rdi
leaq 0x1575(%rip), %rsi      # 0xd06a
pushq $0x13
popq %rdx
xorl %eax, %eax
callq 0x2270
pushq $0x1
popq %rbx
jmp 0xbadd
movq %rax, %rbx
movl $0x3c8, %esi            # imm = 0x3C8
movq %r14, %rdi
callq 0x21b0
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/bokunimowakaru[P]petit15term/petitPanCake.c
// Function: open_serial_port
int open_serial_port(){
	struct termios ComTio;							// シリアル端末設定用の構造体変数
	speed_t speed = B115200;						// 通信速度の設定
	char modem_dev[15]="/dev/ttyUSBx";				// シリアルポートの初期値
	int i;
	for(i=12;i>=-1;i--){
		if(i>=10) snprintf(&modem_dev[5],8,"rfcomm%1d",i-10);	// ポート探索(rfcomm0-2)
		else if(i>=0) snprintf(&modem_dev[5],8,"ttyUSB%1d",i);	// ポート探索(USB0～9)
		else snprintf(&modem_dev[5],8,"ttyAMA0");	// 拡張IOのUART端子に設定
		ComFd=open(modem_dev, O_RDWR|O_NONBLOCK);	// シリアルポートのオープン
		if(ComFd >= 0){ 							// オープン成功時
			printf("com=%s\n",modem_dev);			// 成功したシリアルポートを表示
			tcgetattr(ComFd, &ComTio_Bk);			// 現在のシリアル端末設定状態を保存
			ComTio.c_iflag = 0; 					// シリアル入力設定の初期化
			ComTio.c_oflag = 0; 					// シリアル出力設定の初期化
			ComTio.c_cflag = CLOCAL|CREAD|CS8;		// シリアル制御設定の初期化
			ComTio.c_lflag = 0; 					// シリアルローカル設定の初期化
			bzero(ComTio.c_cc,sizeof(ComTio.c_cc)); // シリアル特殊文字設定の初期化
			cfsetispeed(&ComTio, speed);			// シリアル入力の通信速度の設定
			cfsetospeed(&ComTio, speed);			// シリアル出力の通信速度の設定
			ComTio.c_cc[VMIN] = 0;					// リード待ち容量0バイト(待たない)
			ComTio.c_cc[VTIME] = 0; 				// リード待ち時間0.0秒(待たない)
			tcflush(ComFd,TCIFLUSH);				// バッファのクリア
			tcsetattr(ComFd, TCSANOW, &ComTio); 	// シリアル端末に設定
			break;									// forループを抜ける
		}
	}
	return ComFd;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movabsq $0x7842535579, %rax     # imm = 0x7842535579
leaq 0x5(%rsp), %rbx
movq %rax, 0x2(%rbx)
movabsq $0x7974742f7665642f, %rax # imm = 0x7974742F7665642F
movq %rax, -0x5(%rbx)
pushq $0xc
popq %r14
leaq 0xd5c(%rip), %r15       # 0x2032
pushq $0x8
popq %r12
movq %rsp, %r13
leaq 0xd58(%rip), %rbp       # 0x203c
cmpl $-0x1, %r14d
jl 0x13c3
cmpl $0xa, %r14d
jl 0x1303
leal -0xa(%r14), %ecx
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
jmp 0x1314
testl %r14d, %r14d
js 0x1339
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
movl %r14d, %ecx
xorl %eax, %eax
callq 0x10b0
movq %r13, %rdi
movl $0x802, %esi            # imm = 0x802
xorl %eax, %eax
callq 0x1150
movl %eax, 0x2db4(%rip)      # 0x40e4
decl %r14d
testl %eax, %eax
js 0x12e4
jmp 0x134a
movabsq $0x30414d41797474, %rax # imm = 0x30414D41797474
movq %rax, 0x5(%rsp)
jmp 0x131b
leaq 0xcf5(%rip), %rdi       # 0x2046
movq %rsp, %rsi
xorl %eax, %eax
callq 0x10a0
movl 0x2d83(%rip), %edi      # 0x40e4
leaq 0x2d80(%rip), %rsi      # 0x40e8
callq 0x1130
movaps 0xc9c(%rip), %xmm0      # 0x2010
leaq 0x10(%rsp), %rbx
movaps %xmm0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x11(%rbx)
movups %xmm0, 0x21(%rbx)
movq %rbx, %rdi
movl $0x1002, %esi           # imm = 0x1002
callq 0x1170
movq %rbx, %rdi
movl $0x1002, %esi           # imm = 0x1002
callq 0x1080
andw $0x0, 0x16(%rbx)
movl 0x2d38(%rip), %edi      # 0x40e4
xorl %esi, %esi
callq 0x1090
movl 0x2d2b(%rip), %edi      # 0x40e4
xorl %esi, %esi
movq %rbx, %rdx
callq 0x1140
movl 0x2d1b(%rip), %eax      # 0x40e4
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bokunimowakaru[P]petit15term/petitPanCake.c
// Function: read_serial_port
char read_serial_port(void){
	char c='\0';									// シリアル受信した文字の代入用
	fd_set ComReadFds;								// select命令用構造体ComReadFdを定義
	struct timeval tv;								// タイムアウト値の保持用
	FD_ZERO(&ComReadFds);							// ComReadFdの初期化
	FD_SET(ComFd, &ComReadFds); 					// ファイルディスクリプタを設定
	tv.tv_sec=0; tv.tv_usec=TXL_WAIT;
	if(select(ComFd+1, &ComReadFds, 0, 0, &tv)) read(ComFd, &c, 1); // データを受信
	// usleep(5000);								// 5msの(IchigoJam処理)待ち時間
	return c;										// 戻り値＝受信データ(文字変数c)
}

// Assembly:
pushq %rbx
subq $0xa0, %rsp
movb $0x0, 0xf(%rsp)
xorl %eax, %eax
cmpq $0x10, %rax
je 0x13f8
andq $0x0, 0x20(%rsp,%rax,8)
incq %rax
jmp 0x13e7
movl 0x2ce6(%rip), %edi      # 0x40e4
pushq $0x40
popq %rcx
movl %edi, %eax
cltd
idivl %ecx
movslq %eax, %rdx
shll $0x6, %eax
movl %edi, %ecx
subl %eax, %ecx
pushq $0x1
popq %rax
shlq %cl, %rax
orq %rax, 0x20(%rsp,%rdx,8)
leaq 0x10(%rsp), %r8
andq $0x0, (%r8)
cmpb $0x0, 0x2cf9(%rip)      # 0x4124
movl $0x708, %eax            # imm = 0x708
movl $0x9c4, %ecx            # imm = 0x9C4
cmovneq %rax, %rcx
movq %rcx, 0x8(%r8)
incl %edi
xorl %ebx, %ebx
leaq 0x20(%rsp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1110
testl %eax, %eax
je 0x146b
movl 0x2c8b(%rip), %edi      # 0x40e4
leaq 0xf(%rsp), %rbx
pushq $0x1
popq %rdx
movq %rbx, %rsi
callq 0x10d0
movb (%rbx), %bl
movl %ebx, %eax
addq $0xa0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/bokunimowakaru[P]petit15term/petitPanCake.c
// Function: ahex2i
int ahex2i(char c){
	if(c>='0' && c<='9') return c-'0';
	if(c>='a' && c<='f') return c-'a'+10;
	if(c>='A' && c<='F') return c-'F'+10;
	return -1;
}

// Assembly:
movl %edi, %eax
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x14a5
addl $-0x30, %eax
retq
leal -0x61(%rax), %ecx
cmpb $0x5, %cl
ja 0x14b1
addl $-0x57, %eax
retq
leal -0x41(%rax), %ecx
addl $-0x3c, %eax
cmpb $0x6, %cl
pushq $-0x1
popq %rcx
cmovbl %eax, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lua.c
// Function: main
int main (int argc, char **argv) {
  int status;
  struct Smain s;
  lua_State *L = lua_open();  /* create state */
  if (L == NULL) {
    l_message(argv[0], "cannot create state: not enough memory");
    return EXIT_FAILURE;
  }
  s.argc = argc;
  s.argv = argv;
  status = lua_cpcall(L, &pmain, &s);
  report(L, status);
  lua_close(L);
  return (status || s.status) ? EXIT_FAILURE : EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movl %edi, %ebp
callq 0x1031e
testq %rax, %rax
je 0x46d3
movq %rax, %rbx
movq %rsp, %r15
movl %ebp, (%r15)
movq %r14, 0x8(%r15)
leaq 0x98(%rip), %rsi        # 0x4741
movq %rax, %rdi
movq %r15, %rdx
callq 0x5f74
movl %eax, %ebp
movq %rbx, %rdi
movl %eax, %esi
callq 0x4b8d
movq %rbx, %rdi
callq 0xc334
xorl %eax, %eax
orl 0x10(%r15), %ebp
setne %al
jmp 0x46e5
movq (%r14), %rdi
leaq 0x14927(%rip), %rsi     # 0x19004
callq 0x46f0
pushq $0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lua.c
// Function: report
static int report (lua_State *L, int status) {
  if (status && !lua_isnil(L, -1)) {
    const char *msg = lua_tostring(L, -1);
    if (msg == NULL) msg = "(error object is not a string)";
    l_message(progname, msg);
    lua_pop(L, 1);
  }
  return status;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
testl %esi, %esi
je 0x4bd8
movq %rdi, %r14
pushq $-0x1
popq %rsi
callq 0x543c
testl %eax, %eax
je 0x4bd8
pushq $-0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x5665
testq %rax, %rax
leaq 0x1468d(%rip), %rsi     # 0x1924a
cmovneq %rax, %rsi
movq 0x22708(%rip), %rdi     # 0x272d0
callq 0x46f0
pushq $-0x2
popq %rsi
movq %r14, %rdi
callq 0x51fc
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lua.c
// Function: docall
static int docall (lua_State *L, int narg, int clear) {
  int status;
  int base = lua_gettop(L) - narg;  /* function index */
  lua_pushcfunction(L, traceback);  /* push traceback function */
  lua_insert(L, base);  /* put it under chunk and args */
  signal(SIGINT, laction);
  status = lua_pcall(L, narg, (clear ? 0 : LUA_MULTRET), base);
  signal(SIGINT, SIG_DFL);
  lua_remove(L, base);  /* remove traceback function */
  /* force a complete garbage collection in case of errors */
  if (status != 0) lua_gc(L, LUA_GCCOLLECT, 0);
  return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, %rbx
callq 0x51ef
movl %eax, %ebp
subl %r14d, %ebp
leaq 0x7c(%rip), %rsi        # 0x4ef5
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x599b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5329
leaq 0xf7(%rip), %rsi        # 0x4f8e
pushq $0x2
popq %r13
movl %r13d, %edi
callq 0x4290
cmpl $0x1, %r15d
sbbl %r12d, %r12d
movq %rbx, %rdi
movl %r14d, %esi
movl %r12d, %edx
movl %ebp, %ecx
callq 0x5eec
movl %eax, %r14d
movl %r13d, %edi
xorl %esi, %esi
callq 0x4290
movq %rbx, %rdi
movl %ebp, %esi
callq 0x523b
testl %r14d, %r14d
je 0x4ee3
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x609d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lua.c
// Function: traceback
static int traceback (lua_State *L) {
  if (!lua_isstring(L, 1))  /* 'message' not a string? */
    return 1;  /* keep it intact */
  lua_getfield(L, LUA_GLOBALSINDEX, "debug");
  if (!lua_istable(L, -1)) {
    lua_pop(L, 1);
    return 1;
  }
  lua_getfield(L, -1, "traceback");
  if (!lua_isfunction(L, -1)) {
    lua_pop(L, 2);
    return 1;
  }
  lua_pushvalue(L, 1);  /* pass error message */
  lua_pushinteger(L, 2);  /* skip this function and traceback */
  lua_call(L, 2, 1);  /* call debug.traceback */
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x54c4
testl %eax, %eax
je 0x4f84
leaq 0x14130(%rip), %rdx     # 0x1903e
movq %rbx, %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x5aa6
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x543c
cmpl $0x5, %eax
jne 0x4f75
leaq 0x14112(%rip), %rdx     # 0x19044
pushq $-0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5aa6
movq %rbx, %rdi
movl %ebp, %esi
callq 0x543c
cmpl $0x6, %eax
jne 0x4f79
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x541c
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x57ff
pushq $0x2
popq %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x5eb4
jmp 0x4f84
pushq $-0x2
jmp 0x4f7b
pushq $-0x3
popq %rsi
movq %rbx, %rdi
callq 0x51fc
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lua.c
// Function: pushline
static int pushline (lua_State *L, int firstline) {
  char buffer[LUA_MAXINPUT];
  char *b = buffer;
  size_t l;
  const char *prmt = get_prompt(L, firstline);
  if (lua_readline(L, b, prmt) == 0)
    return 0;  /* no input */
  l = strlen(b);
  if (l > 0 && b[l-1] == '\n')  /* line ends with newline? */
    b[l-1] = '\0';  /* remove it */
  if (firstline && b[0] == '=')  /* first line starts with `=' ? */
    lua_pushfstring(L, "return %s", b+1);  /* change it to `return' */
  else
    lua_pushstring(L, b);
  lua_freeline(L, b);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movl %esi, %ebp
movq %rdi, %rbx
testl %esi, %esi
leaq 0x14247(%rip), %rax     # 0x19235
leaq 0x14238(%rip), %rdx     # 0x1922d
cmoveq %rax, %rdx
leaq 0x1423e(%rip), %rax     # 0x1923e
leaq 0x14238(%rip), %r15     # 0x1923f
cmoveq %rax, %r15
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x5aa6
xorl %r14d, %r14d
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5665
testq %rax, %rax
cmovneq %rax, %r15
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x51fc
movq 0x21f92(%rip), %r12     # 0x26fd0
movq (%r12), %rsi
movq %r15, %rdi
callq 0x41a0
movq (%r12), %rdi
callq 0x4340
movq 0x21f7e(%rip), %rax     # 0x26fd8
movq (%rax), %rdx
movq %rsp, %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x4240
testq %rax, %rax
je 0x50b9
movq %rsp, %rdi
callq 0x4140
testq %rax, %rax
je 0x5088
cmpb $0xa, -0x1(%rsp,%rax)
jne 0x5088
movb $0x0, -0x1(%rsp,%rax)
testl %ebp, %ebp
je 0x50aa
cmpb $0x3d, (%rsp)
jne 0x50aa
leaq 0x1(%rsp), %rdx
leaq 0x14185(%rip), %rsi     # 0x19223
movq %rbx, %rdi
xorl %eax, %eax
callq 0x58eb
jmp 0x50b5
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5870
pushq $0x1
popq %r14
movl %r14d, %eax
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_checkstack
LUA_API int lua_checkstack (lua_State *L, int size) {
  int res = 1;
  lua_lock(L);
  if (size > LUAI_MAXCSTACK || (L->top - L->base + size) > LUAI_MAXCSTACK)
    res = 0;  /* stack overflow */
  else if (size > 0) {
    luaD_checkstack(L, size);
    if (L->ci->top < L->top + size)
      L->ci->top = L->top + size;
  }
  lua_unlock(L);
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
cmpl $0x1f40, %esi           # imm = 0x1F40
jg 0x514b
movq %rdi, %r14
movq 0x10(%rdi), %rax
movq %rax, %rcx
subq 0x18(%rdi), %rcx
sarq $0x4, %rcx
movslq %esi, %r15
addq %r15, %rcx
cmpq $0x1f40, %rcx           # imm = 0x1F40
jg 0x514b
pushq $0x1
popq %rbx
testl %esi, %esi
jle 0x514b
movq 0x38(%r14), %rcx
subq %rax, %rcx
movl %esi, %edx
shll $0x4, %edx
cmpq %rdx, %rcx
jg 0x5136
movq %r14, %rdi
callq 0x7732
movq 0x10(%r14), %rax
movq 0x28(%r14), %rcx
shlq $0x4, %r15
addq %rax, %r15
cmpq %r15, 0x10(%rcx)
jae 0x514b
movq %r15, 0x10(%rcx)
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_xmove
LUA_API void lua_xmove (lua_State *from, lua_State *to, int n) {
  int i;
  if (from == to) return;
  lua_lock(to);
  api_checknelems(from, n);
  api_check(from, G(from) == G(to));
  api_check(from, to->ci->top - to->top >= n);
  from->top -= n;
  for (i = 0; i < n; i++) {
    setobj2s(to, to->top++, from->top + i);
  }
  lua_unlock(to);
}

// Assembly:
cmpq %rsi, %rdi
je 0x519b
movslq %edx, %rax
movq %rax, %rcx
shlq $0x4, %rcx
subq %rcx, 0x10(%rdi)
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
shlq $0x4, %rax
cmpq %rcx, %rax
je 0x519b
movq 0x10(%rdi), %rdx
movq 0x10(%rsi), %r8
leaq 0x10(%r8), %r9
movq %r9, 0x10(%rsi)
movq (%rdx,%rcx), %r9
movq %r9, (%r8)
movl 0x8(%rdx,%rcx), %edx
movl %edx, 0x8(%r8)
addq $0x10, %rcx
jmp 0x5171
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_newthread
LUA_API lua_State *lua_newthread (lua_State *L) {
  lua_State *L1;
  lua_lock(L);
  luaC_checkGC(L);
  L1 = luaE_newthread(L);
  setthvalue(L, L->top, L1);
  api_incr_top(L);
  lua_unlock(L);
  luai_userstatethread(L, L1);
  return L1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0x51d2
movq %rbx, %rdi
callq 0x8b89
movq %rbx, %rdi
callq 0xbf24
movq 0x10(%rbx), %rcx
movq %rax, (%rcx)
movl $0x8, 0x8(%rcx)
addq $0x10, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_settop
LUA_API void lua_settop (lua_State *L, int idx) {
  lua_lock(L);
  if (idx >= 0) {
    api_check(L, idx <= L->stack_last - L->base);
    while (L->top < L->base + idx)
      setnilvalue(L->top++);
    L->top = L->base + idx;
  }
  else {
    api_check(L, -(idx+1) <= (L->top - L->base));
    L->top += idx+1;  /* `subtract' index (index is negative) */
  }
  lua_unlock(L);
}

// Assembly:
testl %esi, %esi
js 0x5224
movl %esi, %eax
shlq $0x4, %rax
addq 0x18(%rdi), %rax
movq 0x10(%rdi), %rcx
cmpq %rax, %rcx
jae 0x5236
leaq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rdi)
andl $0x0, 0x8(%rcx)
movq %rdx, %rcx
jmp 0x520e
movq 0x10(%rdi), %rax
movslq %esi, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
addq $0x10, %rax
movq %rax, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_remove
LUA_API void lua_remove (lua_State *L, int idx) {
  StkId p;
  lua_lock(L);
  p = index2adr(L, idx);
  api_checkvalidindex(L, p);
  while (++p < L->top) setobjs2s(L, p-1, p);
  L->top--;
  lua_unlock(L);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x526a
addq $0x10, %rax
movq 0x10(%rbx), %rcx
cmpq %rcx, %rax
jae 0x5260
movq (%rax), %rcx
movq %rcx, -0x10(%rax)
movl 0x8(%rax), %ecx
movl %ecx, -0x8(%rax)
jmp 0x5244
addq $-0x10, %rcx
movq %rcx, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: index2adr
static TValue *index2adr (lua_State *L, int idx) {
  if (idx > 0) {
    TValue *o = L->base + (idx - 1);
    api_check(L, idx <= L->ci->top - L->base);
    if (o >= L->top) return cast(TValue *, luaO_nilobject);
    else return o;
  }
  else if (idx > LUA_REGISTRYINDEX) {
    api_check(L, idx != 0 && -idx <= L->top - L->base);
    return L->top + idx;
  }
  else switch (idx) {  /* pseudo-indices */
    case LUA_REGISTRYINDEX: return registry(L);
    case LUA_ENVIRONINDEX: {
      Closure *func = curr_func(L);
      sethvalue(L, &L->env, func->c.env);
      return &L->env;
    }
    case LUA_GLOBALSINDEX: return gt(L);
    default: {
      Closure *func = curr_func(L);
      idx = LUA_GLOBALSINDEX - idx;
      return (idx <= func->c.nupvalues)
                ? &func->c.upvalue[idx-1]
                : cast(TValue *, luaO_nilobject);
    }
  }
}

// Assembly:
testl %esi, %esi
jle 0x528f
movq 0x18(%rdi), %rax
movl %esi, %ecx
shlq $0x4, %rcx
addq %rax, %rcx
addq $-0x10, %rcx
cmpq 0x10(%rdi), %rcx
leaq 0x143b6(%rip), %rax     # 0x19640
cmovbq %rcx, %rax
retq
cmpl $0xffffd8f1, %esi       # imm = 0xFFFFD8F1
jl 0x52a3
movslq %esi, %rax
shlq $0x4, %rax
addq 0x10(%rdi), %rax
retq
cmpl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
je 0x52ed
cmpl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
je 0x52c5
cmpl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
jne 0x52f5
movl $0xa0, %eax
addq 0x20(%rdi), %rax
retq
movq 0x28(%rdi), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
leaq 0x88(%rdi), %rax
movq 0x18(%rcx), %rcx
movq %rcx, 0x88(%rdi)
movl $0x5, 0x90(%rdi)
retq
addq $0x78, %rdi
movq %rdi, %rax
retq
movq 0x28(%rdi), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movl $0xffffd8ee, %ecx       # imm = 0xFFFFD8EE
subl %esi, %ecx
movzbl 0xb(%rax), %edx
movl $0xffffd8ed, %edi       # imm = 0xFFFFD8ED
subl %esi, %edi
shlq $0x4, %rdi
cmpl %edx, %ecx
leaq 0x28(%rax,%rdi), %rcx
leaq 0x1431c(%rip), %rax     # 0x19640
cmovbeq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_insert
LUA_API void lua_insert (lua_State *L, int idx) {
  StkId p;
  StkId q;
  lua_lock(L);
  p = index2adr(L, idx);
  api_checkvalidindex(L, p);
  for (q = L->top; q>p; q--) setobjs2s(L, q, q-1);
  setobjs2s(L, p, L->top);
  lua_unlock(L);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x526a
movq 0x10(%rbx), %rcx
cmpq %rax, %rcx
jbe 0x534e
movq -0x10(%rcx), %rdx
movq %rdx, (%rcx)
movl -0x8(%rcx), %edx
movl %edx, 0x8(%rcx)
addq $-0x10, %rcx
jmp 0x5336
movq 0x10(%rbx), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_replace
LUA_API void lua_replace (lua_State *L, int idx) {
  StkId o;
  lua_lock(L);
  /* explicit test for incompatible code */
  if (idx == LUA_ENVIRONINDEX && L->ci == L->base_ci)
    luaG_runerror(L, "no calling environment");
  api_checknelems(L, 1);
  o = index2adr(L, idx);
  api_checkvalidindex(L, o);
  if (idx == LUA_ENVIRONINDEX) {
    Closure *func = curr_func(L);
    api_check(L, ttistable(L->top - 1)); 
    func->c.env = hvalue(L->top - 1);
    luaC_barrier(L, func, L->top - 1);
  }
  else {
    setobj(L, o, L->top - 1);
    if (idx < LUA_GLOBALSINDEX)  /* function upvalue? */
      luaC_barrier(L, curr_func(L), L->top - 1);
  }
  L->top--;
  lua_unlock(L);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0xffffd8ef, %esi       # imm = 0xFFFFD8EF
jne 0x538b
movq 0x28(%rbx), %rax
cmpq 0x50(%rbx), %rax
jne 0x538b
leaq 0x13fcc(%rip), %rsi     # 0x1934d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7165
movq %rbx, %rdi
movl %ebp, %esi
callq 0x526a
cmpl $0xffffd8ef, %ebp       # imm = 0xFFFFD8EF
jne 0x53ca
movq 0x10(%rbx), %rax
movq 0x28(%rbx), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rsi
movq -0x10(%rax), %rax
movq %rax, 0x18(%rsi)
movq 0x10(%rbx), %rax
cmpl $0x4, -0x8(%rax)
jl 0x5410
movq -0x10(%rax), %rdx
testb $0x3, 0x9(%rdx)
jne 0x5402
jmp 0x5410
movq 0x10(%rbx), %rcx
movq -0x10(%rcx), %rdx
movq %rdx, (%rax)
movl -0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
cmpl $0xffffd8ed, %ebp       # imm = 0xFFFFD8ED
jg 0x5410
movq 0x10(%rbx), %rax
cmpl $0x4, -0x8(%rax)
jl 0x5410
movq -0x10(%rax), %rdx
testb $0x3, 0x9(%rdx)
je 0x5410
movq 0x28(%rbx), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
testb $0x4, 0x9(%rsi)
je 0x5410
movq %rbx, %rdi
callq 0x9066
addq $-0x10, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_rawequal
LUA_API int lua_rawequal (lua_State *L, int index1, int index2) {
  StkId o1 = index2adr(L, index1);
  StkId o2 = index2adr(L, index2);
  return (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0
         : luaO_rawequalObj(o1, o2);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %r14
callq 0x526a
movq %rax, %rbx
movq %r14, %rdi
movl %ebp, %esi
callq 0x526a
leaq 0x14129(%rip), %rcx     # 0x19640
cmpq %rcx, %rbx
sete %dl
cmpq %rcx, %rax
sete %cl
orb %dl, %cl
je 0x552e
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x9860
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_equal
LUA_API int lua_equal (lua_State *L, int index1, int index2) {
  StkId o1, o2;
  int i;
  lua_lock(L);  /* may call tag method */
  o1 = index2adr(L, index1);
  o2 = index2adr(L, index2);
  i = (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0 : equalobj(L, o1, o2);
  lua_unlock(L);
  return i;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
callq 0x526a
movq %rax, %r14
movq %rbx, %rdi
movl %ebp, %esi
callq 0x526a
movq %rax, %rdx
leaq 0x140de(%rip), %rax     # 0x19640
cmpq %rax, %r14
sete %cl
cmpq %rax, %rdx
sete %sil
xorl %eax, %eax
orb %cl, %sil
jne 0x5593
movl 0x8(%r14), %ecx
cmpl 0x8(%rdx), %ecx
jne 0x5593
movq %rbx, %rdi
movq %r14, %rsi
callq 0xdd66
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_lessthan
LUA_API int lua_lessthan (lua_State *L, int index1, int index2) {
  StkId o1, o2;
  int i;
  lua_lock(L);  /* may call tag method */
  o1 = index2adr(L, index1);
  o2 = index2adr(L, index2);
  i = (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0
       : luaV_lessthan(L, o1, o2);
  lua_unlock(L);
  return i;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
callq 0x526a
movq %rax, %r14
movq %rbx, %rdi
movl %ebp, %esi
callq 0x526a
leaq 0x14086(%rip), %rcx     # 0x19640
cmpq %rcx, %r14
sete %dl
cmpq %rcx, %rax
sete %cl
orb %dl, %cl
je 0x55d1
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0xdbfc
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_tonumber
LUA_API lua_Number lua_tonumber (lua_State *L, int idx) {
  TValue n;
  const TValue *o = index2adr(L, idx);
  if (tonumber(o, &n))
    return nvalue(o);
  else
    return 0;
}

// Assembly:
subq $0x18, %rsp
callq 0x526a
cmpl $0x3, 0x8(%rax)
je 0x5604
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0xd800
testq %rax, %rax
je 0x560d
movsd (%rax), %xmm0
addq $0x18, %rsp
retq
xorps %xmm0, %xmm0
jmp 0x5608
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_tointeger
LUA_API lua_Integer lua_tointeger (lua_State *L, int idx) {
  TValue n;
  const TValue *o = index2adr(L, idx);
  if (tonumber(o, &n)) {
    lua_Integer res;
    lua_Number num = nvalue(o);
    lua_number2integer(res, num);
    return res;
  }
  else
    return 0;
}

// Assembly:
subq $0x18, %rsp
callq 0x526a
cmpl $0x3, 0x8(%rax)
je 0x5633
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0xd800
testq %rax, %rax
je 0x563d
cvttsd2si (%rax), %rax
addq $0x18, %rsp
retq
xorl %eax, %eax
jmp 0x5638
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_tolstring
LUA_API const char *lua_tolstring (lua_State *L, int idx, size_t *len) {
  StkId o = index2adr(L, idx);
  if (!ttisstring(o)) {
    lua_lock(L);  /* `luaV_tostring' may create a new string */
    if (!luaV_tostring(L, o)) {  /* conversion failed? */
      if (len != NULL) *len = 0;
      lua_unlock(L);
      return NULL;
    }
    luaC_checkGC(L);
    o = index2adr(L, idx);  /* previous call may reallocate the stack */
    lua_unlock(L);
  }
  if (len != NULL) *len = tsvalue(o)->len;
  return svalue(o);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x526a
cmpl $0x4, 0x8(%rax)
je 0x56ab
movq %r14, %rdi
movq %rax, %rsi
callq 0xd84d
testl %eax, %eax
je 0x56c6
movq 0x20(%r14), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0x56a1
movq %r14, %rdi
callq 0x8b89
movq %r14, %rdi
movl %ebp, %esi
callq 0x526a
testq %rbx, %rbx
je 0x56ba
movq (%rax), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rax
addq $0x18, %rax
popq %rbx
popq %r14
popq %rbp
retq
testq %rbx, %rbx
je 0x56cf
andq $0x0, (%rbx)
xorl %eax, %eax
jmp 0x56c1
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_objlen
LUA_API size_t lua_objlen (lua_State *L, int idx) {
  StkId o = index2adr(L, idx);
  switch (ttype(o)) {
    case LUA_TSTRING: return tsvalue(o)->len;
    case LUA_TUSERDATA: return uvalue(o)->len;
    case LUA_TTABLE: return luaH_getn(hvalue(o));
    case LUA_TNUMBER: {
      size_t l;
      lua_lock(L);  /* `luaV_tostring' may create a new string */
      l = (luaV_tostring(L, o) ? tsvalue(o)->len : 0);
      lua_unlock(L);
      return l;
    }
    default: return 0;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x526a
movq %rax, %rbx
movl 0x8(%rax), %ecx
xorl %eax, %eax
addl $-0x3, %ecx
cmpl $0x4, %ecx
ja 0x572e
leaq 0x13b7a(%rip), %rdx     # 0x19270
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd84d
testl %eax, %eax
je 0x572c
movq (%rbx), %rax
movq 0x10(%rax), %rax
jmp 0x572e
movq (%rbx), %rdi
callq 0xd034
cltq
jmp 0x572e
movq (%rbx), %rax
movq 0x20(%rax), %rax
jmp 0x572e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_touserdata
LUA_API void *lua_touserdata (lua_State *L, int idx) {
  StkId o = index2adr(L, idx);
  switch (ttype(o)) {
    case LUA_TUSERDATA: return (rawuvalue(o) + 1);
    case LUA_TLIGHTUSERDATA: return pvalue(o);
    default: return NULL;
  }
}

// Assembly:
pushq %rax
callq 0x526a
movl 0x8(%rax), %ecx
cmpl $0x2, %ecx
je 0x5771
cmpl $0x7, %ecx
jne 0x5776
movq (%rax), %rax
addq $0x28, %rax
jmp 0x5778
movq (%rax), %rax
jmp 0x5778
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_topointer
LUA_API const void *lua_topointer (lua_State *L, int idx) {
  StkId o = index2adr(L, idx);
  switch (ttype(o)) {
    case LUA_TTABLE: return hvalue(o);
    case LUA_TFUNCTION: return clvalue(o);
    case LUA_TTHREAD: return thvalue(o);
    case LUA_TUSERDATA:
    case LUA_TLIGHTUSERDATA:
      return lua_touserdata(L, idx);
    default: return NULL;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x526a
movq %rax, %rcx
movl 0x8(%rax), %edx
xorl %eax, %eax
addl $-0x2, %edx
cmpl $0x6, %edx
ja 0x57c0
leaq 0x13ad0(%rip), %rsi     # 0x19284
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
movq (%rcx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5755
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_pushlstring
LUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len) {
  lua_lock(L);
  luaC_checkGC(L);
  setsvalue2s(L, L->top, luaS_newlstr(L, s, len));
  api_incr_top(L);
  lua_unlock(L);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0x5840
movq %rbx, %rdi
callq 0x8b89
movq 0x10(%rbx), %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xc466
movq %rax, (%r12)
movl $0x4, 0x8(%r12)
addq $0x10, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_pushstring
LUA_API void lua_pushstring (lua_State *L, const char *s) {
  if (s == NULL)
    lua_pushnil(L);
  else
    lua_pushlstring(L, s, strlen(s));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x589c
movq %rsi, %r14
movq %rsi, %rdi
callq 0x4140
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5819
movq 0x10(%rbx), %rax
andl $0x0, 0x8(%rax)
addq $0x10, %rax
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_pushcclosure
LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {
  Closure *cl;
  lua_lock(L);
  luaC_checkGC(L);
  api_checknelems(L, n);
  cl = luaF_newCclosure(L, n, getcurrenv(L));
  cl->c.f = fn;
  L->top -= n;
  while (n--)
    setobj2n(L, &cl->c.upvalue[n], L->top+n);
  setclvalue(L, L->top, cl);
  lua_assert(iswhite(obj2gco(cl)));
  api_incr_top(L);
  lua_unlock(L);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0x59bd
movq %rbx, %rdi
callq 0x8b89
movq 0x28(%rbx), %rax
cmpq 0x50(%rbx), %rax
je 0x59d4
movq 0x8(%rax), %rax
movq (%rax), %rax
addq $0x18, %rax
jmp 0x59d8
leaq 0x78(%rbx), %rax
movq (%rax), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x84d4
movq %r14, 0x20(%rax)
movslq %ebp, %rcx
movq %rcx, %rdx
shlq $0x4, %rdx
subq %rdx, 0x10(%rbx)
addq $0x18, %rdx
subq $0x1, %rcx
jb 0x5a1c
movq 0x10(%rbx), %rsi
movq -0x28(%rdx,%rsi), %rdi
movq %rdi, (%rax,%rdx)
movl -0x20(%rdx,%rsi), %esi
movl %esi, 0x8(%rax,%rdx)
addq $-0x10, %rdx
jmp 0x59fb
movq 0x10(%rbx), %rcx
movq %rax, (%rcx)
movl $0x6, 0x8(%rcx)
addq $0x10, 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_getfield
LUA_API void lua_getfield (lua_State *L, int idx, const char *k) {
  StkId t;
  TValue key;
  lua_lock(L);
  t = index2adr(L, idx);
  api_checkvalidindex(L, t);
  setsvalue(L, &key, luaS_new(L, k));
  luaV_gettable(L, t, &key, L->top);
  api_incr_top(L);
  lua_unlock(L);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
callq 0x526a
movq %rax, %r15
movq %rbx, %rdi
callq 0x4140
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xc466
movq %rsp, %rdx
movq %rax, (%rdx)
movl $0x4, 0x8(%rdx)
movq 0x10(%r14), %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0xd8a9
addq $0x10, 0x10(%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_rawgeti
LUA_API void lua_rawgeti (lua_State *L, int idx, int n) {
  StkId o;
  lua_lock(L);
  o = index2adr(L, idx);
  api_check(L, ttistable(o));
  setobj2s(L, L->top, luaH_getnum(hvalue(o), n));
  api_incr_top(L);
  lua_unlock(L);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
callq 0x526a
movq (%rax), %rdi
movl %ebx, %esi
callq 0xcb10
movq 0x10(%r14), %rcx
movq (%rax), %rdx
movq %rdx, (%rcx)
movl 0x8(%rax), %eax
movl %eax, 0x8(%rcx)
addq $0x10, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/lua/src/lapi.c
// Function: lua_createtable
LUA_API void lua_createtable (lua_State *L, int narray, int nrec) {
  lua_lock(L);
  luaC_checkGC(L);
  sethvalue(L, L->top, luaH_new(L, narray, nrec));
  api_incr_top(L);
  lua_unlock(L);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
jb 0x5b84
movq %rbx, %rdi
callq 0x8b89
movq 0x10(%rbx), %r15
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0xc90c
movq %rax, (%r15)
movl $0x5, 0x8(%r15)
addq $0x10, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq