LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/./merge8.h
// Function: init_arrays8_largealpha
static void init_arrays8_largealpha(g_data *g)
{
  assert(!g->extMem);                 // if extMem we do not want to reread the text
  // compute bwtOcc on the spot with a complete scan of input BWTs
  assert(g->bwtOcc==NULL);
  g->bwtOcc = malloc(g->numBwt*sizeof(customInt *));
  if(!g->bwtOcc) die(__func__);
  for(int i=0;i<g->numBwt;i++) {
    g->bwtOcc[i] = calloc(g->sizeOfAlpha,sizeof(customInt));
    if(!g->bwtOcc[i]) die(__func__);
    init_freq_no0(g->bws[i],g->bwtLen[i],g->bwtOcc[i]); 
  }
  init_arrays8(g);
  for(int i=0;i<g->numBwt;i++)
    free(g->bwtOcc[i]);
  free(g->bwtOcc);
  g->bwtOcc=NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movslq 0x20(%rax), %rdi
shlq $0x3, %rdi
callq 0x127b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x9b7f
leaq 0xc553(%rip), %rdi      # 0x160cd
callq 0x3ce0
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x9c2c
movq 0x10(%rsp), %rax
movslq 0x38(%rax), %rdi
movl $0x8, %esi
callq 0x12a60
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0xc(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x9be2
leaq 0xc4f0(%rip), %rdi      # 0x160cd
callq 0x3ce0
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x12360
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x9b87
movq 0x10(%rsp), %rdi
callq 0x9a10
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x9c70
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x12940
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x9c3e
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x12940
movq 0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/./merge16.h
// Function: init_arrays16
static void init_arrays16(g_data *g)
{
  assert(g->numBwt<=16);
  customInt i=0; // position inside Z newZ and B  

  for(int j=0;j<g->sizeOfAlpha;j++) {
    if(g->bwtOnly) tba_or_m(g->bitB,i,1);
    else g->blockBeginsAt[i]=1;  // start of symbol j, correct lcp is 0
    g->firstColumn[j] = i;  // symbol j starts at position i    
    for(int b=0;b<g->numBwt;b++) {
      for(customInt t=0;t<g->bwtOcc[b][j];t++) {
        if(j==0) { // zero chars are all different, Z are newZ do not change 
          if(g->bwtOnly) tba_or_m(g->bitB,i,1);
          else g->blockBeginsAt[i]=1;  
        }
        g->mergeColor[i++] = b*17;      // write b in both cur and next
      } // end for t
    } // end for b 
  } // end for j
  assert(i==g->mergeLen);
  // extra check on mergeColor, can be commented out
  #ifndef NDEBUG
  customInt cnt[MAX_NUMBER_OF_BWTS] = {0};
  for(i=0;i<g->mergeLen;i++) cnt[g->mergeColor[i]&0xF]++;
  bool stop=false;
  for(int i=0; i<g->numBwt; i++)
    if(cnt[i]!=g->bwtLen[i]) {
      printf("INIT %d cnt:"CUSTOM_FORMAT" len:"CUSTOM_FORMAT"\n",i,cnt[i],g->bwtLen[i]);
      stop=true;
    }
  assert(!stop);
  #endif
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x38(%rcx), %eax
jge 0xae40
movq 0x20(%rsp), %rax
testb $0x1, 0x3c(%rax)
je 0xad24
movq 0x20(%rsp), %rax
movq 0x98(%rax), %rdi
movq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0x11120
jmp 0xad39
movq 0x20(%rsp), %rax
movq 0x98(%rax), %rax
movq 0x18(%rsp), %rcx
movb $0x1, (%rax,%rcx)
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rax
movq 0x5108(%rax), %rax
movslq 0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jge 0xae2e
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x18(%rcx), %rcx
movslq 0x10(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x14(%rsp), %rdx
cmpq (%rcx,%rdx,8), %rax
jae 0xae1c
cmpl $0x0, 0x14(%rsp)
jne 0xade2
movq 0x20(%rsp), %rax
testb $0x1, 0x3c(%rax)
je 0xadcb
movq 0x20(%rsp), %rax
movq 0x98(%rax), %rdi
movq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0x11120
jmp 0xade0
movq 0x20(%rsp), %rax
movq 0x98(%rax), %rax
movq 0x18(%rsp), %rcx
movb $0x1, (%rax,%rcx)
jmp 0xade2
imull $0x11, 0x10(%rsp), %eax
movb %al, %dl
movq 0x20(%rsp), %rax
movq 0x50e8(%rax), %rax
movq 0x18(%rsp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x18(%rsp)
movb %dl, (%rax,%rcx)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0xad76
jmp 0xae1e
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0xad5b
jmp 0xae30
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xacea
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/./merge16.h
// Function: init_arrays16_largealpha
static void init_arrays16_largealpha(g_data *g)
{
  // compute bwtOcc on the spot with a complete scan of input BWTs
  assert(g->bwtOcc==NULL);
  g->bwtOcc = malloc(g->numBwt*sizeof(customInt *));
  if(!g->bwtOcc) die(__func__);
  for(int i=0;i<g->numBwt;i++) {
    g->bwtOcc[i] = calloc(g->sizeOfAlpha,sizeof(customInt));
    if(!g->bwtOcc[i]) die(__func__);
    init_freq_no0(g->bws[i],g->bwtLen[i],g->bwtOcc[i]);
  }
  init_arrays16(g);
  for(int i=0;i<g->numBwt;i++)
    free(g->bwtOcc[i]);
  free(g->bwtOcc);
  g->bwtOcc=NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movslq 0x20(%rax), %rdi
shlq $0x3, %rdi
callq 0x127b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xae8f
leaq 0xb2db(%rip), %rdi      # 0x16165
callq 0x3ce0
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jge 0xaf3c
movq 0x10(%rsp), %rax
movslq 0x38(%rax), %rdi
movl $0x8, %esi
callq 0x12a60
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0xc(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0xaef2
leaq 0xb278(%rip), %rdi      # 0x16165
callq 0x3ce0
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x12360
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xae97
movq 0x10(%rsp), %rdi
callq 0xacd0
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jge 0xaf80
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x12940
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xaf4e
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x12940
movq 0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/./merge128.h
// Function: init_arrays128
static void init_arrays128(g_data *g)
{
  assert(g->numBwt<=128);
  customInt i=0; // position inside Z newZ and B  

  for(int j=0;j<g->sizeOfAlpha;j++) {
    tba_or_m16(g->mergeColor16,i,1);
    g->firstColumn[j] = i;  // symbol j starts at position i
    for(int b=0;b<g->numBwt;b++) {
      for(customInt t=0;t<g->bwtOcc[b][j];t++) {
        if(j==0)   // zero chars are all different, Z are newZ do not change 
          tba_or_m16(g->mergeColor16,i,1);
        g->mergeColor16[i++] |= b*129;      // write b in both cur and next
      } // end for t
    } // end for b 
  } // end for j
  assert(i==g->mergeLen); 
  // extra check on mergeColor, can be commented out
  #ifndef NDEBUG
  customInt cnt[MAX_NUMBER_OF_BWTS] = {0};
  for(i=0;i<g->mergeLen;i++) cnt[g->mergeColor16[i]&0x7F]++;
  bool stop=false;
  for(int i=0; i<g->numBwt; i++)
    if(cnt[i]!=g->bwtLen[i]) {
      printf("INIT %d cnt:"CUSTOM_FORMAT" len:"CUSTOM_FORMAT"\n",i,cnt[i],g->bwtLen[i]);
      stop=true;
    }
  assert(!stop);
  #endif
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x38(%rcx), %eax
jge 0xc14e
movq 0x20(%rsp), %rax
movq 0x50f8(%rax), %rdi
movq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0x112d0
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rax
movq 0x5108(%rax), %rax
movslq 0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jge 0xc13c
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x18(%rcx), %rcx
movslq 0x10(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x14(%rsp), %rdx
cmpq (%rcx,%rdx,8), %rax
jae 0xc12a
cmpl $0x0, 0x14(%rsp)
jne 0xc0e8
movq 0x20(%rsp), %rax
movq 0x50f8(%rax), %rdi
movq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0x112d0
imull $0x81, 0x10(%rsp), %esi
movq 0x20(%rsp), %rax
movq 0x50f8(%rax), %rax
movq 0x18(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x18(%rsp)
movzwl (%rax,%rcx,2), %edx
orl %esi, %edx
movw %dx, (%rax,%rcx,2)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0xc0a4
jmp 0xc12c
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0xc089
jmp 0xc13e
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xc03a
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/./merge128.h
// Function: init_arrays128_largealpha
static void init_arrays128_largealpha(g_data *g)
{
  assert(!g->extMem);                 // if extMem we do not want to reread the text
  // compute bwtOcc on the spot with a complete scan of input BWTs
  assert(g->bwtOcc==NULL);
  g->bwtOcc = malloc(g->numBwt*sizeof(customInt *));
  if(!g->bwtOcc) die(__func__);
  for(int i=0;i<g->numBwt;i++) {
    g->bwtOcc[i] = calloc(g->sizeOfAlpha,sizeof(customInt));
    if(!g->bwtOcc[i]) die(__func__);
    init_freq_no0(g->bws[i],g->bwtLen[i],g->bwtOcc[i]); 
  }
  init_arrays128(g);
  for(int i=0;i<g->numBwt;i++)
    free(g->bwtOcc[i]);
  free(g->bwtOcc);
  g->bwtOcc=NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movslq 0x20(%rax), %rdi
shlq $0x3, %rdi
callq 0x127b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xc19f
leaq 0x9fe4(%rip), %rdi      # 0x1617e
callq 0x3ce0
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jge 0xc24c
movq 0x10(%rsp), %rax
movslq 0x38(%rax), %rdi
movl $0x8, %esi
callq 0x12a60
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0xc(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0xc202
leaq 0x9f81(%rip), %rdi      # 0x1617e
callq 0x3ce0
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x12360
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xc1a7
movq 0x10(%rsp), %rdi
callq 0xc020
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jge 0xc290
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x12940
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xc25e
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x12940
movq 0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/./merge256.h
// Function: init_arrays256
static void init_arrays256(g_data *g)
{
  assert(g->numBwt<=256);
  customInt i=0; // position inside Z newZ and B  

  for(int j=0;j<g->sizeOfAlpha;j++) {
    set_blockBeginsAt(i,1);   // start of symbol j, correct lcp is 0
    g->firstColumn[j] = i;    // symbol j starts at position i    
    for(int b=0;b<g->numBwt;b++) {
      for(customInt t=0;t<g->bwtOcc[b][j];t++) {
        if(j==0)  // zero chars are all different, Z are newZ do not change 
          set_blockBeginsAt(i,1);  
        g->array32[i++] |= b*257;      // write b in both cur and next
      } // end for t
    } // end for b 
  } // end for j
  assert(i==g->mergeLen);
  // extra check on mergeColor, can be commented out
  #ifndef NDEBUG
  customInt cnt[MAX_NUMBER_OF_BWTS] = {0};
  for(i=0;i<g->mergeLen;i++) cnt[g->array32[i]&0xFF]++;
  bool stop=false;
  for(int i=0; i<g->numBwt; i++)
    if(cnt[i]!=g->bwtLen[i]) {
      printf("INIT %d cnt:"CUSTOM_FORMAT" len:"CUSTOM_FORMAT"\n",i,cnt[i],g->bwtLen[i]);
      stop=true;
    }
  assert(!stop);
  #endif
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq $0x0, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movl -0x14(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x38(%rcx), %eax
jge 0xe398
movq -0x8(%rsp), %rax
movq 0x5100(%rax), %rax
movq -0x10(%rsp), %rcx
movl (%rax,%rcx,4), %edx
andl $0xffff, %edx           # imm = 0xFFFF
orl $0x10000, %edx          # imm = 0x10000
movq -0x8(%rsp), %rax
movq 0x5100(%rax), %rax
movq -0x10(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rsp), %rdx
movq -0x8(%rsp), %rax
movq 0x5108(%rax), %rax
movslq -0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x18(%rsp)
movl -0x18(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jge 0xe386
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq -0x8(%rsp), %rcx
movq 0x18(%rcx), %rcx
movslq -0x18(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x14(%rsp), %rdx
cmpq (%rcx,%rdx,8), %rax
jae 0xe374
cmpl $0x0, -0x14(%rsp)
jne 0xe336
movq -0x8(%rsp), %rax
movq 0x5100(%rax), %rax
movq -0x10(%rsp), %rcx
movl (%rax,%rcx,4), %edx
andl $0xffff, %edx           # imm = 0xFFFF
orl $0x10000, %edx          # imm = 0x10000
movq -0x8(%rsp), %rax
movq 0x5100(%rax), %rax
movq -0x10(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
imull $0x101, -0x18(%rsp), %edx # imm = 0x101
movq -0x8(%rsp), %rax
movq 0x5100(%rax), %rax
movq -0x10(%rsp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x10(%rsp)
orl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0xe2d9
jmp 0xe376
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0xe2be
jmp 0xe388
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0xe256
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/./merge256.h
// Function: init_arrays256_largealpha
static void init_arrays256_largealpha(g_data *g)
{
  assert(!g->extMem);                 // if extMem we do not want to reread the text
  // compute bwtOcc on the spot with a complete scan of input BWTs
  assert(g->bwtOcc==NULL);
  g->bwtOcc = malloc(g->numBwt*sizeof(customInt *));
  if(!g->bwtOcc) die(__func__);
  for(int i=0;i<g->numBwt;i++) {
    g->bwtOcc[i] = calloc(g->sizeOfAlpha,sizeof(customInt));
    if(!g->bwtOcc[i]) die(__func__);
    init_freq_no0(g->bws[i],g->bwtLen[i],g->bwtOcc[i]);
  }
  init_arrays256(g);
  for(int i=0;i<g->numBwt;i++)
    free(g->bwtOcc[i]);
  free(g->bwtOcc);
  g->bwtOcc=NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movslq 0x20(%rax), %rdi
shlq $0x3, %rdi
callq 0x127b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xe3df
leaq 0x7ed8(%rip), %rdi      # 0x162b2
callq 0x3ce0
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jge 0xe48c
movq 0x10(%rsp), %rax
movslq 0x38(%rax), %rdi
movl $0x8, %esi
callq 0x12a60
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0xc(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0xe442
leaq 0x7e75(%rip), %rdi      # 0x162b2
callq 0x3ce0
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x12360
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xe3e7
movq 0x10(%rsp), %rdi
callq 0xe240
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jge 0xe4d0
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x12940
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xe49e
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x12940
movq 0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/./blocks.h
// Function: block_inflate
static void block_inflate(solidBlock *b, solidBlockFile *s) {
  assert(b->endsAt - b->beginsAt <= SMALLSOLID_LIMIT);
  customInt *bigOcc = get_occ(s);
  for (int i = 0; i < s->occ_size; ++i) {
    bigOcc[i] = (customInt) b->smallOcc[i];
  }
  free_smallocc(b->smallOcc,s);
  b->occ = bigOcc;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x8830
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x105e2
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
movl %eax, %edx
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x105a5
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x8950
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/./blocks.h
// Function: tba_block_test_set8
static inline bool tba_block_test_set8(uint8_t *a,customInt i, int m, bool *recent)
{
  assert(m==1 || m==2);
  int b2 = (a[i] >> 6) & 3;       // shift and check 2 msb 
  if(b2==3-m) {
    *recent = true;
    a[i] = a[i] | ( 3 << 6); // make the block not recent 
    return true;
  }
  else if(b2==3) {
    *recent = false;
    return true;
  }
  return false; // do not change recent 
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl %edx, -0x1c(%rsp)
movq %rcx, -0x28(%rsp)
movq -0x10(%rsp), %rax
movq -0x18(%rsp), %rcx
movzbl (%rax,%rcx), %eax
sarl $0x6, %eax
andl $0x3, %eax
movl %eax, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
movl $0x3, %ecx
subl -0x1c(%rsp), %ecx
cmpl %ecx, %eax
jne 0x1091d
movq -0x28(%rsp), %rax
movb $0x1, (%rax)
movq -0x10(%rsp), %rax
movq -0x18(%rsp), %rcx
movzbl (%rax,%rcx), %eax
orl $0xc0, %eax
movb %al, %dl
movq -0x10(%rsp), %rax
movq -0x18(%rsp), %rcx
movb %dl, (%rax,%rcx)
movb $0x1, -0x1(%rsp)
jmp 0x1093a
cmpl $0x3, -0x2c(%rsp)
jne 0x10933
movq -0x28(%rsp), %rax
movb $0x0, (%rax)
movb $0x1, -0x1(%rsp)
jmp 0x1093a
jmp 0x10935
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/./blocks.h
// Function: add_singleton2liquid
static void add_singleton2liquid(protoBlock *proto,liquidBlock *liquid)
{
  assert(liquid->endsAt==proto->beginsAt);
  assert(proto->endsAt==proto->beginsAt+1);
  liquid->endsAt=proto->endsAt;
  // update color occurrences 
  liquid->occ[proto->lastColor] += 1;
  // update alpha occurences 
  liquid->occ[liquid->numBwt + proto->lastChar] +=1;
  liquid->empty = false;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rsp), %rcx
movslq 0x24(%rcx), %rcx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rsp), %rcx
movl 0x10(%rcx), %ecx
movq -0x8(%rsp), %rdx
addl 0x20(%rdx), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rsp), %rax
movb $0x0, 0x2c(%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/./blocks.h
// Function: add_proto2liquid
static void add_proto2liquid(protoBlock *proto,liquidBlock *liquid)
{
  assert(liquid->endsAt==proto->beginsAt);
  assert(proto->endsAt>proto->beginsAt+1);
  liquid->endsAt=proto->endsAt;
  // update color occurrences
  assert(proto->color==proto->lastColor); 
  liquid->occ[proto->color] += (proto->endsAt-proto->beginsAt);
  // update alpha occurences 
  for(int i=0;i<proto->endsAt-proto->beginsAt;i++)
    liquid->occ[liquid->numBwt + (proto->start)[i]] +=1;
  liquid->empty = false;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rsp), %rax
subq (%rax), %rdx
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rsp), %rcx
movslq 0x1c(%rcx), %rcx
addq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x14(%rsp)
movslq -0x14(%rsp), %rax
movq -0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq -0x8(%rsp), %rdx
subq (%rdx), %rcx
cmpq %rcx, %rax
jae 0x10a6b
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rsp), %rcx
movl 0x10(%rcx), %ecx
movq -0x8(%rsp), %rdx
movq 0x10(%rdx), %rdx
movslq -0x14(%rsp), %rsi
movzbl (%rdx,%rsi), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x10a0f
movq -0x10(%rsp), %rax
movb $0x0, 0x2c(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/./blocks.h
// Function: tba_block_test_set
static inline bool tba_block_test_set(uint64_t *a,customInt i, int m, bool *recent)
{
  assert(m==1 || m==2);
  customInt q = i/32;
  customInt r = i%32;
  int b2 = (a[q] >> (2*r)) & 3;       // shift and check last 2 bits
  if(b2==3-m) {
    *recent = true;
    a[q] = a[q] | ( (uint64_t) 3 << (2*r)); // make the block not recent 
    return true;
  }
  else if(b2==3) {
    *recent = false;
    return true;
  }
  return false; // do not change recent 
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl %edx, -0x1c(%rsp)
movq %rcx, -0x28(%rsp)
movq -0x18(%rsp), %rax
shrq $0x5, %rax
movq %rax, -0x30(%rsp)
movq -0x18(%rsp), %rax
andq $0x1f, %rax
movq %rax, -0x38(%rsp)
movq -0x10(%rsp), %rax
movq -0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x38(%rsp), %rcx
shlq %rcx
shrq %cl, %rax
andq $0x3, %rax
movl %eax, -0x3c(%rsp)
movl -0x3c(%rsp), %eax
movl $0x3, %ecx
subl -0x1c(%rsp), %ecx
cmpl %ecx, %eax
jne 0x1121f
movq -0x28(%rsp), %rax
movb $0x1, (%rax)
movq -0x10(%rsp), %rax
movq -0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x38(%rsp), %rcx
shlq %rcx
movl $0x3, %eax
shlq %cl, %rax
orq %rax, %rdx
movq -0x10(%rsp), %rax
movq -0x30(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movb $0x1, -0x1(%rsp)
jmp 0x1123c
cmpl $0x3, -0x3c(%rsp)
jne 0x11235
movq -0x28(%rsp), %rax
movb $0x0, (%rax)
movb $0x1, -0x1(%rsp)
jmp 0x1123c
jmp 0x11237
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/./blocks.h
// Function: tba_mark_if0
static inline void tba_mark_if0(uint64_t *a, customInt i, uint64_t m)
{
  assert(m==1 || m==2);
  customInt q = i/32;
  customInt r = i%32;
  if( ((a[q]>> (2*r)) & 3) == 0)
    a[q] = a[q] | (m<< (2*r));
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x10(%rsp), %rax
shrq $0x5, %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
andq $0x1f, %rax
movq %rax, -0x28(%rsp)
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x28(%rsp), %rcx
shlq %rcx
shrq %cl, %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x112cd
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rsp), %rax
movq -0x28(%rsp), %rcx
shlq %rcx
shlq %cl, %rax
orq %rax, %rdx
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/./blocks.h
// Function: tba_block_test_set16
static inline bool tba_block_test_set16(uint16_t *a,customInt i, int m, bool *recent)
{
  assert(m==1 || m==2);
  int b2 = (a[i] >> 14) & 3;       // shift and check 2 msb 
  if(b2==3-m) {
    *recent = true;
    a[i] = a[i] | ( 3 << 14); // make the block not recent 
    return true;
  }
  else if(b2==3) {
    *recent = false;
    return true;
  }
  return false; // do not change recent 
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl %edx, -0x1c(%rsp)
movq %rcx, -0x28(%rsp)
movq -0x10(%rsp), %rax
movq -0x18(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
sarl $0xe, %eax
andl $0x3, %eax
movl %eax, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
movl $0x3, %ecx
subl -0x1c(%rsp), %ecx
cmpl %ecx, %eax
jne 0x1137f
movq -0x28(%rsp), %rax
movb $0x1, (%rax)
movq -0x10(%rsp), %rax
movq -0x18(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
orl $0xc000, %eax           # imm = 0xC000
movw %ax, %dx
movq -0x10(%rsp), %rax
movq -0x18(%rsp), %rcx
movw %dx, (%rax,%rcx,2)
movb $0x1, -0x1(%rsp)
jmp 0x1139c
cmpl $0x3, -0x2c(%rsp)
jne 0x11395
movq -0x28(%rsp), %rax
movb $0x0, (%rax)
movb $0x1, -0x1(%rsp)
jmp 0x1139c
jmp 0x11397
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/mergegap.c
// Function: open_merge_files
static void open_merge_files(g_data *g) {
  assert(g->extMem);
  // mergeColor file for reading (Z in pseudocode)
  g->fmergeColor = fopen(g->merge_fname,"rb");
  if(!g->fmergeColor) die("merge_open");
  #ifndef NDEBUG
  customInt c[256] = {0}; // init to zero
  for(customInt i = 0; i < g->mergeLen; i++) {
    int col=fread_color(g->fmergeColor);
    col &= 0x7F;
    assert(col>=0 && col<g->numBwt);
    c[col]++;
  }
  for(int i=0;i<g->numBwt;i++) 
    assert(c[i]==g->bwtLen[i]);
  rewind(g->fmergeColor);
  #endif
  // alphaSize-1 newMergeColor cwriters for writing (newZ in pseudocode)
  int fd = open(g->newmerge_fname,O_WRONLY);
  if(fd == -1) die("new_merge_open");
  g->fnewMergeColor = malloc(g->sizeOfAlpha*sizeof(cwriter));
  if(g->fnewMergeColor==NULL) die("new_merge_alloc");
  g->fnewMergeColor[0].fd = -1; // invalid file descriptor
  for(int i=1; i< g->sizeOfAlpha; i++)
    cwriter_init(&g->fnewMergeColor[i],fd,COLOR_WBUFFER_SIZE, g->firstColumn[i]*sizeof(palette));
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x50d8(%rax), %rdi
leaq 0x4393(%rip), %rsi      # 0x157ff
callq 0x21d0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x50c8(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x50c8(%rax)
jne 0x1149b
leaq 0x4dbe(%rip), %rdi      # 0x16254
callq 0x3ce0
movq 0x10(%rsp), %rax
movq 0x50e0(%rax), %rdi
movl $0x1, %esi
movb $0x0, %al
callq 0x22e0
movl %eax, 0xc(%rsp)
cmpl $-0x1, 0xc(%rsp)
jne 0x114ca
leaq 0x4d8b(%rip), %rdi      # 0x16250
callq 0x3ce0
movq 0x10(%rsp), %rax
movslq 0x38(%rax), %rdi
shlq $0x5, %rdi
callq 0x127b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x50d0(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x50d0(%rax)
jne 0x11506
leaq 0x4d5e(%rip), %rdi      # 0x1625f
callq 0x3ce0
movq 0x10(%rsp), %rax
movq 0x50d0(%rax), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0x1, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x38(%rcx), %eax
jge 0x1157a
movq 0x10(%rsp), %rax
movq 0x50d0(%rax), %rdi
movslq 0x8(%rsp), %rax
shlq $0x5, %rax
addq %rax, %rdi
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rax
movq 0x5108(%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
shlq $0x0, %rcx
movl $0x100000, %edx         # imm = 0x100000
callq 0x7aa0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x11520
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/mergegap.c
// Function: fread_color
static int fread_color(FILE *f) {
  int b=0;
  int e = fread(&b,sizeof(palette),1,f);
  if(e!=1) die(__func__);
  return b;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rcx
leaq 0xc(%rsp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x2090
movl %eax, 0x8(%rsp)
cmpl $0x1, 0x8(%rsp)
je 0x115bf
leaq 0x4cb5(%rip), %rdi      # 0x1626f
callq 0x3ce0
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/mergegap.c
// Function: close_merge_files
static void close_merge_files(g_data *g) {
  assert(g->extMem);
  // close new merge files
  for(int i=1; i< g->sizeOfAlpha; i++) 
    cwriter_close(&g->fnewMergeColor[i]);
  close(g->fnewMergeColor[1].fd); // close file   
  free(g->fnewMergeColor);
  // close merge file
  int e = fclose(g->fmergeColor);
  if(e!=0) die("merge_close");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x38(%rcx), %eax
jge 0x119d9
movq 0x10(%rsp), %rax
movq 0x50d0(%rax), %rdi
movslq 0xc(%rsp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x7a60
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x119a1
movq 0x10(%rsp), %rax
movq 0x50d0(%rax), %rax
movl 0x20(%rax), %edi
callq 0x2150
movq 0x10(%rsp), %rax
movq 0x50d0(%rax), %rdi
callq 0x12940
movq 0x10(%rsp), %rax
movq 0x50c8(%rax), %rdi
callq 0x20d0
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
je 0x11a26
leaq 0x4885(%rip), %rdi      # 0x162a6
callq 0x3ce0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/mergehm.c
// Function: init_arrays
static void init_arrays(g_data *g)
{
  customInt i=0; // position inside Z newZ and B 
  for(int j=0;j<g->sizeOfAlpha;j++) {
    if(!g->bwtOnly) g->blockBeginsAt[i]=1;
    g->firstColumn[j] = i;                    // symbol j starts at position i
    for(int b=0;b<g->numBwt;b++)         // scan all occs of symbol j
      for(customInt t=0;t<g->bwtOcc[b][j];t++) {
        if(j==0) { // zero chars are all different, Z are newZ do not change 
          assert(j==0);     // no sqeezing: only zero char is zero
          if(!g->bwtOnly) g->blockBeginsAt[i]=1;
          g->newMergeColor[i]=b;          //for 0-chars write b to both Z and newZ 
        }
        g->mergeColor[i++] = b;
      }
  }
  assert(i==g->mergeLen);
  // extra check on mergeColor, can be commented out
  #ifndef NDEBUG
  customInt cnt[MAX_NUMBER_OF_BWTS] = {0};
  for(i=0;i<g->mergeLen;i++) cnt[g->mergeColor[i]]++;
  bool stop=false;
  for(int i=0; i<g->numBwt; i++)
    if(cnt[i]!=g->bwtLen[i]) {
      printf("INIT %d cnt:"CUSTOM_FORMAT" len:"CUSTOM_FORMAT"\n",i,cnt[i],g->bwtLen[i]);
      stop=true;
    }
  assert(!stop);
  #endif
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq $0x0, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movl -0x14(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x38(%rcx), %eax
jge 0x11e35
movq -0x8(%rsp), %rax
testb $0x1, 0x3c(%rax)
jne 0x11d38
movq -0x8(%rsp), %rax
movq 0x98(%rax), %rax
movq -0x10(%rsp), %rcx
movb $0x1, (%rax,%rcx)
movq -0x10(%rsp), %rdx
movq -0x8(%rsp), %rax
movq 0x5108(%rax), %rax
movslq -0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x18(%rsp)
movl -0x18(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x11e23
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq -0x8(%rsp), %rcx
movq 0x18(%rcx), %rcx
movslq -0x18(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x14(%rsp), %rdx
cmpq (%rcx,%rdx,8), %rax
jae 0x11e11
cmpl $0x0, -0x14(%rsp)
jne 0x11dd8
movq -0x8(%rsp), %rax
testb $0x1, 0x3c(%rax)
jne 0x11dbe
movq -0x8(%rsp), %rax
movq 0x98(%rax), %rax
movq -0x10(%rsp), %rcx
movb $0x1, (%rax,%rcx)
movl -0x18(%rsp), %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movq 0x50f0(%rax), %rax
movq -0x10(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rsp), %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movq 0x50e8(%rax), %rax
movq -0x10(%rsp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x10(%rsp)
movb %dl, (%rax,%rcx)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x11d75
jmp 0x11e13
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x11d5a
jmp 0x11e25
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x11d06
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/mergehm.c
// Function: init_arrays_largealpha
static void init_arrays_largealpha(g_data *g)
{  
  // compute bwtOcc on the spot with a complete scan of input BWTs
  assert(g->bwtOcc==NULL);
  g->bwtOcc = malloc(g->numBwt*sizeof(customInt *));
  if(!g->bwtOcc) die(__func__);
  for(int i=0;i<g->numBwt;i++) {
    g->bwtOcc[i] = calloc(g->sizeOfAlpha,sizeof(customInt));
    if(!g->bwtOcc[i]) die(__func__);
    init_freq_no0(g->bws[i],g->bwtLen[i],g->bwtOcc[i]); 
  }
  init_arrays(g);
  for(int i=0;i<g->numBwt;i++)
    free(g->bwtOcc[i]);
  free(g->bwtOcc);
  g->bwtOcc=NULL;
    
  #ifndef NDEBUG
  // extra check on mergeColor
  customInt cnx[MAX_NUMBER_OF_BWTS] = {0};
  for(int i=0;i<g->mergeLen;i++) cnx[g->mergeColor[i]]++;
  bool stop=false;
  for(int i=0; i<g->numBwt; i++)
    if(cnx[i]!=g->bwtLen[i]) {
      printf("INIT %d cnx:"CUSTOM_FORMAT" len:"CUSTOM_FORMAT"\n",i,cnx[i],g->bwtLen[i]);
      stop=true;
    }
  assert(!stop);
  #endif
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movslq 0x20(%rax), %rdi
shlq $0x3, %rdi
callq 0x127b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x11e7f
leaq 0x4452(%rip), %rdi      # 0x162cc
callq 0x3ce0
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x11f2c
movq 0x10(%rsp), %rax
movslq 0x38(%rax), %rdi
movl $0x8, %esi
callq 0x12a60
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0xc(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x11ee2
leaq 0x43ef(%rip), %rdi      # 0x162cc
callq 0x3ce0
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x12360
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x11e87
movq 0x10(%rsp), %rdi
callq 0x11cf0
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x11f70
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x12940
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x11f3e
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x12940
movq 0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/alphabet.c
// Function: init_freq
void init_freq(symbol *b, customInt n, customInt *freq)
{
  for(int i=0;i<SIZE_OF_ALPHABET;i++)
    freq[i]=0;
  for(customInt i=0;i<n;i++)
    freq[b[i]]++;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
cmpl $0x100, -0x1c(%rsp)     # imm = 0x100
jge 0x12310
movq -0x18(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x122e7
movq $0x0, -0x28(%rsp)
movq -0x28(%rsp), %rax
cmpq -0x10(%rsp), %rax
jae 0x12354
movq -0x18(%rsp), %rax
movq -0x8(%rsp), %rcx
movq -0x28(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x12319
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/alphabet.c
// Function: init_alpha_maps
int init_alpha_maps(g_data *g)
{
  
  // init maps with illegal value -1
  for(int i=0;i<SIZE_OF_ALPHABET;i++)
    alphabet_map[i]=restricted_unmap[i] = ILLEGAL_SYMBOL;

  // compute frequencies of the input symbols
  customInt freq[SIZE_OF_ALPHABET];
  customInt n = g->mergeLen;
  init_freq(g->bws[0],n,freq); // complete scan of bws[0][0..n]
  // compute maps
  int j=0;
  for(int i=0;i<SIZE_OF_ALPHABET;i++)
    if(freq[i]!=0) {
      alphabet_map[i] = j;
      restricted_unmap[j++] = i;
    }
  return j;
}

// Assembly:
subq $0x828, %rsp            # imm = 0x828
movq %rdi, 0x820(%rsp)
movl $0x0, 0x81c(%rsp)
cmpl $0x100, 0x81c(%rsp) # imm = 0x100
jge 0x12426
movslq 0x81c(%rsp), %rcx
leaq 0x6e2a(%rip), %rax      # 0x19220
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movslq 0x81c(%rsp), %rcx
leaq 0x7214(%rip), %rax      # 0x19620
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl 0x81c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x81c(%rsp)
jmp 0x123da
movq 0x820(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x820(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x122d0
movl $0x0, 0x4(%rsp)
movl $0x0, (%rsp)
cmpl $0x100, (%rsp)          # imm = 0x100
jge 0x124b4
movslq (%rsp), %rax
cmpq $0x0, 0x10(%rsp,%rax,8)
je 0x124a7
movl 0x4(%rsp), %edx
movslq (%rsp), %rcx
leaq 0x7199(%rip), %rax      # 0x19620
movl %edx, (%rax,%rcx,4)
movl (%rsp), %edx
movl 0x4(%rsp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rsp)
movslq %eax, %rcx
leaq 0x6d7c(%rip), %rax      # 0x19220
movl %edx, (%rax,%rcx,4)
jmp 0x124a9
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x12463
movl 0x4(%rsp), %eax
addq $0x828, %rsp            # imm = 0x828
retq
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/alphabet.c
// Function: remap_bwts
void remap_bwts(g_data *g)
{
  int sizeOfAlphabet; // size of alphabet
  
  // remap alphabet, remap bwts and compute occ 
  sizeOfAlphabet = init_alpha_maps(g);
  assert(sizeOfAlphabet>1 && sizeOfAlphabet<= SIZE_OF_ALPHABET);
  if(g->verbose>0) printf("Alphabet size: %d\n", sizeOfAlphabet);
  
  // remap; also compute Occs for each BWT if smallAlpha
  if(g->smallAlpha) {
    g->bwtOcc = malloc(g->numBwt*sizeof(customInt *));
    if(!g->bwtOcc) die(__func__);
    g->bwtOcc[0] = calloc(g->numBwt*sizeOfAlphabet,sizeof(customInt));
   if(!g->bwtOcc[0]) die(__func__);
  }  
  for(int i=0;i<g->numBwt;i++) {
    customInt *bwtOcc = NULL;
    if(g->smallAlpha) { // if the alphabet is small keep bwtOcc[i]
      if(i>0) g->bwtOcc[i] = g->bwtOcc[i-1] + sizeOfAlphabet;
      bwtOcc = g->bwtOcc[i];
    }
    remap_string(g->bws[i],g->bwtLen[i],bwtOcc);
  }
  g->sizeOfAlpha = sizeOfAlphabet;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x123c0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x94(%rax)
jle 0x12537
movl 0xc(%rsp), %esi
leaq 0x2530(%rip), %rdi      # 0x14a60
movb $0x0, %al
callq 0x20f0
movq 0x10(%rsp), %rax
testb $0x1, 0x68(%rax)
je 0x125be
movq 0x10(%rsp), %rax
movslq 0x20(%rax), %rdi
shlq $0x3, %rdi
callq 0x127b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x12578
leaq 0x3dcc(%rip), %rdi      # 0x1633f
callq 0x3ce0
movq 0x10(%rsp), %rax
movl 0x20(%rax), %eax
imull 0xc(%rsp), %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x12a60
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, (%rax)
jne 0x125bc
leaq 0x3d88(%rip), %rdi      # 0x1633f
callq 0x3ce0
jmp 0x125be
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x12679
movq $0x0, (%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0x68(%rax)
je 0x1263d
cmpl $0x0, 0x8(%rsp)
jle 0x12627
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x8(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movslq 0xc(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq (%rsp), %rdx
callq 0x12690
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x125c6
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x38(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/malloc_count/malloc_count.c
// Function: inc_count
static void inc_count(size_t inc)
{
#if THREAD_SAFE_GCC_INTRINSICS
    long long mycurr = __sync_add_and_fetch(&curr, inc);
    if (mycurr > peak) peak = mycurr;
    total += inc;
    if (callback) callback(callback_cookie, mycurr);
#else
    if ((curr += inc) > peak) peak = curr;
    total += inc;
    if (callback) callback(callback_cookie, curr);
#endif
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, %rax
lock
xaddq %rax, 0x7146(%rip)      # 0x19a20
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x713a(%rip), %rax      # 0x19a28
jle 0x128fc
movq 0x8(%rsp), %rax
movq %rax, 0x712c(%rip)      # 0x19a28
movq 0x10(%rsp), %rax
addq 0x107158(%rip), %rax    # 0x119a60
movq %rax, 0x107151(%rip)    # 0x119a60
cmpq $0x0, 0x7119(%rip)      # 0x19a30
je 0x1292e
movq 0x7110(%rip), %rax      # 0x19a30
movq 0x7111(%rip), %rdi      # 0x19a38
movq 0x8(%rsp), %rsi
callq *%rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/threads.c
// Function: pc_system_init
void pc_system_init(pc_system *pc, int buf_size)
{
  pc->buf_size = buf_size; 
  pc->pindex=0;
  pc->cindex=0;
  pc->free_slots = xsem_create_destroy(NULL,buf_size,__LINE__,__FILE__);
  pc->ready = xsem_create_destroy(NULL,0,__LINE__,__FILE__);
  int e = pthread_mutex_init(&(pc->cmutex),NULL);
  if(e) die(__func__);
  // re condition variable and related mutex
  e = pthread_mutex_init(&(pc->remutex),NULL);
  if(e) die(__func__);
  e = pthread_cond_init(&(pc->recond),NULL);
  if(e) die(__func__);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x48(%rax)
movq 0x10(%rsp), %rax
movl $0x0, (%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x4(%rax)
movl 0xc(%rsp), %esi
xorl %eax, %eax
movl %eax, %edi
movl $0x7f, %edx
leaq 0x368f(%rip), %rcx      # 0x16493
callq 0x12ec0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x30(%rax)
xorl %eax, %eax
movl %eax, %edi
xorl %esi, %esi
movl $0x80, %edx
leaq 0x366c(%rip), %rcx      # 0x16493
callq 0x12ec0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x23c0
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
je 0x12e61
leaq 0x3641(%rip), %rdi      # 0x1649d
callq 0x3ce0
movq 0x10(%rsp), %rdi
addq $0x50, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x23c0
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
je 0x12e8a
leaq 0x3618(%rip), %rdi      # 0x1649d
callq 0x3ce0
movq 0x10(%rsp), %rdi
addq $0x78, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2210
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
je 0x12eb3
leaq 0x35ef(%rip), %rdi      # 0x1649d
callq 0x3ce0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/threads.c
// Function: pc_system_destroy
void pc_system_destroy(pc_system *pc)
{
  assert(pc->pindex==pc->cindex);  
  int e = pthread_cond_destroy(&(pc->recond));
  if(e) die(__func__);
  e = pthread_mutex_destroy(&(pc->remutex));
  if(e) die(__func__);
  e = pthread_mutex_destroy(&(pc->cmutex));
  if(e) die(__func__);
  xsem_create_destroy(pc->ready,0,__LINE__,__FILE__);
  xsem_create_destroy(pc->free_slots,0,__LINE__,__FILE__);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
addq $0x78, %rdi
callq 0x2300
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x1306e
leaq 0x3443(%rip), %rdi      # 0x164ac
callq 0x3ce0
movq 0x10(%rsp), %rdi
addq $0x50, %rdi
callq 0x2120
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x13093
leaq 0x341e(%rip), %rdi      # 0x164ac
callq 0x3ce0
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x2120
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x130b8
leaq 0x33f9(%rip), %rdi      # 0x164ac
callq 0x3ce0
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rdi
xorl %esi, %esi
movl $0x94, %edx
leaq 0x33c4(%rip), %rcx      # 0x16493
callq 0x12ec0
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
xorl %esi, %esi
movl $0x95, %edx
leaq 0x33a8(%rip), %rcx      # 0x16493
callq 0x12ec0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dropletzhu[P]msuite/mlistener.c
// Function: usage
void usage()
{
	printf("Usage: ./mlistener -s source -g group -p port -l length \n");
	printf(" -s souurce	use the source to select bind device\n");
	printf(" -g group	the group to listen\n");
	printf(" -p port	the port to listen\n");
	printf(" -l length	the packet length, default length is 256 bytes\n");
	printf(" Version 	%s\n", version);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xdfd(%rip), %rdi       # 0x2038
movb $0x0, %al
callq 0x1070
leaq 0xe29(%rip), %rdi       # 0x2072
movb $0x0, %al
callq 0x1070
leaq 0xe4d(%rip), %rdi       # 0x20a4
movb $0x0, %al
callq 0x1070
leaq 0xe5e(%rip), %rdi       # 0x20c3
movb $0x0, %al
callq 0x1070
leaq 0xe6d(%rip), %rdi       # 0x20e0
movb $0x0, %al
callq 0x1070
leaq 0xe9a(%rip), %rdi       # 0x211b
leaq 0xea1(%rip), %rsi       # 0x2129
movb $0x0, %al
callq 0x1070
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dropletzhu[P]msuite/mlistener.c
// Function: term_handler
void term_handler(int signum)
{
	unsigned int s_total, i;

	for( i = 0; i < 65535; i++ ) {
		s_total += s_count[i];
	}

	printf("Total received:	%u\n", l_count);
	printf("Total sent:	%u\n", s_total);
	/* the s_count may not be updated when interrupt the
	   process */
	if( l_count <= s_total )
		printf("Total lost:	%u\n", s_total - l_count);
	else
		printf("Total lost: 0\n");

	exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0xffff, -0xc(%rbp)     # imm = 0xFFFF
jae 0x12db
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x2e09(%rip), %rax      # 0x40d0
movl (%rax,%rcx,4), %eax
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x12b2
movl 0x2ddf(%rip), %esi      # 0x40c0
leaq 0xe45(%rip), %rdi       # 0x212d
movb $0x0, %al
callq 0x1070
movl -0x8(%rbp), %esi
leaq 0xe48(%rip), %rdi       # 0x2141
movb $0x0, %al
callq 0x1070
movl 0x2dba(%rip), %eax      # 0x40c0
cmpl -0x8(%rbp), %eax
ja 0x1324
movl -0x8(%rbp), %esi
subl 0x2dac(%rip), %esi      # 0x40c0
leaq 0xe36(%rip), %rdi       # 0x2151
movb $0x0, %al
callq 0x1070
jmp 0x1332
leaq 0xe36(%rip), %rdi       # 0x2161
movb $0x0, %al
callq 0x1070
xorl %edi, %edi
callq 0x1110
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_strnlen_s
size_t
kmip_strnlen_s(const char *str, size_t strsz)
{
    if(str == NULL)
    {
        return(0);
    }
    
    size_t length = 0;
    for(const char *i = str; *i != 0; i++)
    {
        length++;
        if(length >= strsz)
        {
            return(strsz);
        }
    }
    return(length);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x703d
movq $0x0, -0x8(%rbp)
jmp 0x7091
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x7089
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x7079
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7091
jmp 0x707b
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x704d
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)