LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: checkHashSn
bool checkHashSn(Read* r, HashAln** table,
    uint32_t hashSize, File dups, bool dupsVerb,
    bool gzOut) {
  for (int k = 0; k < r->alnLen; k++) {
    Aln* a = r->aln + k;
    uint32_t pos = (a->strand ? a->pos[0] : a->pos[1]);
    uint32_t idx = jenkins_hash_aln(a->chrom, NULL,
      pos, 0, a->strand, 0, SINGLE, hashSize);
    HashAln* h = checkHash(a->chrom, NULL, pos, 0,
      a->strand, 0, SINGLE, table, idx);
    if (h) {
      if (dupsVerb)
        logDup(dups, gzOut, r->name, a->chrom, NULL,
          pos, 0, a->strand, 0, h->name, SINGLE);
      return true;
    }
  }
  return false;
}

// Assembly:
subq $0x78, %rsp
movl %r8d, 0x2c(%rsp)
movq %rcx, %r8
movl 0x2c(%rsp), %ecx
movb %r9b, %al
movq %r8, 0x68(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
andb $0x1, %cl
movb %cl, 0x53(%rsp)
andb $0x1, %al
movb %al, 0x52(%rsp)
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movq 0x60(%rsp), %rcx
movzbl 0x10(%rcx), %ecx
cmpl %ecx, %eax
jge 0x11bf6
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x4c(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
testb $0x1, 0x10(%rax)
je 0x11ac2
movq 0x40(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x28(%rsp)
jmp 0x11ace
movq 0x40(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x3c(%rsp)
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rdi
movl 0x3c(%rsp), %edx
movq 0x40(%rsp), %rax
movb 0x10(%rax), %r8b
movl 0x54(%rsp), %eax
xorl %ecx, %ecx
movl %ecx, %esi
xorl %r9d, %r9d
andb $0x1, %r8b
movl %r9d, %ecx
movzbl %r8b, %r8d
movl $0x1, (%rsp)
movl %eax, 0x8(%rsp)
callq 0xf450
movl %eax, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rdi
movl 0x3c(%rsp), %edx
movq 0x40(%rsp), %rax
movb 0x10(%rax), %r8b
movq 0x58(%rsp), %r10
movl 0x38(%rsp), %eax
xorl %ecx, %ecx
movl %ecx, %esi
xorl %r9d, %r9d
andb $0x1, %r8b
movl %r9d, %ecx
movzbl %r8b, %r8d
movl $0x1, (%rsp)
movq %r10, 0x8(%rsp)
movl %eax, 0x10(%rsp)
callq 0xf850
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x11be4
testb $0x1, 0x53(%rsp)
je 0x11bdd
movb 0x52(%rsp), %sil
movq 0x60(%rsp), %rax
movq (%rax), %rdx
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rcx
movl 0x3c(%rsp), %r9d
movq 0x40(%rsp), %rax
movb 0x10(%rax), %r10b
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x68(%rsp), %rdi
xorl %r8d, %r8d
xorl %r11d, %r11d
andb $0x1, %sil
andb $0x1, %r10b
movzbl %sil, %esi
movl $0x0, (%rsp)
movzbl %r10b, %r10d
movl %r10d, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movl $0x1, 0x20(%rsp)
callq 0xfb40
movb $0x1, 0x77(%rsp)
jmp 0x11bfb
jmp 0x11be6
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x11a7b
movb $0x0, 0x77(%rsp)
movb 0x77(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: updatePairedAln
void updatePairedAln(Aln* a, uint16_t flag,
    uint32_t pos, int length, float score) {
  if (flag & 0x40)
    a->pos[0] = flag & 0x10 ? pos + length : pos;
  else
    a->pos[1] = flag & 0x10 ? pos + length : pos;
  if (score == NOSCORE)
    a->score = NOSCORE;
  else if (a->score != NOSCORE)
    a->score += score;
  a->full = true;
}

// Assembly:
movw %si, %ax
movq %rdi, -0x8(%rsp)
movw %ax, -0xa(%rsp)
movl %edx, -0x10(%rsp)
movl %ecx, -0x14(%rsp)
movss %xmm0, -0x18(%rsp)
movzwl -0xa(%rsp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x13498
movzwl -0xa(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x13483
movl -0x10(%rsp), %eax
addl -0x14(%rsp), %eax
movl %eax, -0x1c(%rsp)
jmp 0x1348b
movl -0x10(%rsp), %eax
movl %eax, -0x1c(%rsp)
movl -0x1c(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, (%rax)
jmp 0x134c7
movzwl -0xa(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x134b3
movl -0x10(%rsp), %eax
addl -0x14(%rsp), %eax
movl %eax, -0x20(%rsp)
jmp 0x134bb
movl -0x10(%rsp), %eax
movl %eax, -0x20(%rsp)
movl -0x20(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x4(%rax)
movss -0x18(%rsp), %xmm0
movss 0xacdf(%rip), %xmm1     # 0x1e1b4
ucomiss %xmm1, %xmm0
jne 0x134f0
jp 0x134f0
movq -0x8(%rsp), %rax
movss 0xaccb(%rip), %xmm0     # 0x1e1b4
movss %xmm0, 0x8(%rax)
jmp 0x13522
movq -0x8(%rsp), %rax
movss 0x8(%rax), %xmm0
movss 0xacb2(%rip), %xmm1     # 0x1e1b4
ucomiss %xmm1, %xmm0
jne 0x1350b
jp 0x1350b
jmp 0x13520
movss -0x18(%rsp), %xmm0
movq -0x8(%rsp), %rax
addss 0x8(%rax), %xmm0
movss %xmm0, 0x8(%rax)
jmp 0x13522
movq -0x8(%rsp), %rax
movb $0x1, 0xe(%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: savePairedAln
bool savePairedAln(Aln** aln, int* alnLen,
    uint16_t flag, Chrom* chrom, uint32_t pos,
    int length, uint32_t pnext, float score) {

  // check for excessive alignments
  if (*alnLen == MAX_ALNS)
    return false;

  // save aln info
  Aln* a = *aln + *alnLen;
  a->chrom = chrom;
  a->score = score;
  a->primary = (bool) (!(flag & 0x100));
  a->full = false;
  a->paired = true;

  // save positions for this aln (corrected if rev-comp),
  //   and for its pair (pnext, uncorrected)
  if (flag & 0x40) {
    a->pos[0] = flag & 0x10 ? pos + length : pos;
    a->pos[1] = pnext;
    a->first = true;
  } else {
    a->pos[0] = pnext;
    a->pos[1] = flag & 0x10 ? pos + length : pos;
    a->first = false;
  }

  (*alnLen)++;
  return true;
}

// Assembly:
movw %dx, %ax
movl 0x8(%rsp), %edx
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movw %ax, -0x1a(%rsp)
movq %rcx, -0x28(%rsp)
movl %r8d, -0x2c(%rsp)
movl %r9d, -0x30(%rsp)
movss %xmm0, -0x34(%rsp)
movq -0x18(%rsp), %rax
cmpl $0x80, (%rax)
jne 0x13572
movb $0x0, -0x1(%rsp)
jmp 0x13682
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x18(%rsp), %rcx
movslq (%rcx), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rsp)
movq -0x28(%rsp), %rcx
movq -0x40(%rsp), %rax
movq %rcx, 0x20(%rax)
movss -0x34(%rsp), %xmm0
movq -0x40(%rsp), %rax
movss %xmm0, 0x8(%rax)
movzwl -0x1a(%rsp), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
setne %cl
xorb $-0x1, %cl
movq -0x40(%rsp), %rax
andb $0x1, %cl
movb %cl, 0xc(%rax)
movq -0x40(%rsp), %rax
movb $0x0, 0xe(%rax)
movq -0x40(%rsp), %rax
movb $0x1, 0xd(%rax)
movzwl -0x1a(%rsp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x1362e
movzwl -0x1a(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x13604
movl -0x2c(%rsp), %eax
addl -0x30(%rsp), %eax
movl %eax, -0x44(%rsp)
jmp 0x1360c
movl -0x2c(%rsp), %eax
movl %eax, -0x44(%rsp)
movl -0x44(%rsp), %ecx
movq -0x40(%rsp), %rax
movl %ecx, (%rax)
movl 0x8(%rsp), %ecx
movq -0x40(%rsp), %rax
movl %ecx, 0x4(%rax)
movq -0x40(%rsp), %rax
movb $0x1, 0xf(%rax)
jmp 0x13671
movl 0x8(%rsp), %ecx
movq -0x40(%rsp), %rax
movl %ecx, (%rax)
movzwl -0x1a(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x13654
movl -0x2c(%rsp), %eax
addl -0x30(%rsp), %eax
movl %eax, -0x48(%rsp)
jmp 0x1365c
movl -0x2c(%rsp), %eax
movl %eax, -0x48(%rsp)
movl -0x48(%rsp), %ecx
movq -0x40(%rsp), %rax
movl %ecx, 0x4(%rax)
movq -0x40(%rsp), %rax
movb $0x0, 0xf(%rax)
movq -0x18(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: saveSingleAln
bool saveSingleAln(Aln** aln, int* alnLen,
    uint16_t flag, Chrom* chrom, uint32_t pos,
    int length, float score) {

  // check for excessive alignments
  if (*alnLen == MAX_ALNS)
    return false;

  // save aln info
  Aln* a = *aln + *alnLen;
  a->chrom = chrom;
  a->score = score;
  a->primary = (bool) (!(flag & 0x100));
  a->paired = false;
  a->strand = (bool) (!(flag & 0x10));
  a->first = (bool) (flag & 0x40);
  a->pos[0] = pos;
  a->pos[1] = pos + length;
  (*alnLen)++;
  return true;
}

// Assembly:
movw %dx, %ax
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movw %ax, -0x1a(%rsp)
movq %rcx, -0x28(%rsp)
movl %r8d, -0x2c(%rsp)
movl %r9d, -0x30(%rsp)
movss %xmm0, -0x34(%rsp)
movq -0x18(%rsp), %rax
cmpl $0x80, (%rax)
jne 0x136ce
movb $0x0, -0x1(%rsp)
jmp 0x13790
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x18(%rsp), %rcx
movslq (%rcx), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rsp)
movq -0x28(%rsp), %rcx
movq -0x40(%rsp), %rax
movq %rcx, 0x20(%rax)
movss -0x34(%rsp), %xmm0
movq -0x40(%rsp), %rax
movss %xmm0, 0x8(%rax)
movzwl -0x1a(%rsp), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
setne %cl
xorb $-0x1, %cl
movq -0x40(%rsp), %rax
andb $0x1, %cl
movb %cl, 0xc(%rax)
movq -0x40(%rsp), %rax
movb $0x0, 0xd(%rax)
movzwl -0x1a(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
setne %cl
xorb $-0x1, %cl
movq -0x40(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x10(%rax)
movzwl -0x1a(%rsp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
setne %cl
movq -0x40(%rsp), %rax
andb $0x1, %cl
movb %cl, 0xf(%rax)
movl -0x2c(%rsp), %ecx
movq -0x40(%rsp), %rax
movl %ecx, (%rax)
movl -0x2c(%rsp), %ecx
addl -0x30(%rsp), %ecx
movq -0x40(%rsp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: sumQual
uint16_t sumQual(char* qual, int len, int offset) {
  if (qual[0] == 0xFF)  // BAM 'null' value
    return 0;
  int sum = 0;
  for (int i = 0; i < len; i++)
    sum += qual[i] - offset;
  return sum > UINT16_MAX ? UINT16_MAX : (uint16_t) sum;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movl %edx, -0x18(%rsp)
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xff, %eax
jne 0x137c5
movw $0x0, -0x2(%rsp)
jmp 0x1382f
movl $0x0, -0x1c(%rsp)
movl $0x0, -0x20(%rsp)
movl -0x20(%rsp), %eax
cmpl -0x14(%rsp), %eax
jge 0x13806
movq -0x10(%rsp), %rax
movslq -0x20(%rsp), %rcx
movsbl (%rax,%rcx), %eax
subl -0x18(%rsp), %eax
addl -0x1c(%rsp), %eax
movl %eax, -0x1c(%rsp)
movl -0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x137d5
cmpl $0xffff, -0x1c(%rsp)    # imm = 0xFFFF
jle 0x1381b
movl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x24(%rsp)
jmp 0x13826
movl -0x1c(%rsp), %eax
movzwl %ax, %eax
movl %eax, -0x24(%rsp)
movl -0x24(%rsp), %eax
movw %ax, -0x2(%rsp)
movw -0x2(%rsp), %ax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: getScore
float getScore(char* extra) {
  if (extra == NULL)
    return NOSCORE;
  char* end;
  char* field = strtok_r(extra, TAB, &end);
  while (field != NULL) {
    char* tag = strtok(field, COL);
    if (!strcmp(tag, SCORE)) {
      for (int i = 0; i < 2; i++) {
        tag = strtok(NULL, COL);
        if (tag == NULL)
          return NOSCORE;
        if (i)
          return getFloat(tag);
      }
    }
    field = strtok_r(NULL, TAB, &end);
  }
  return NOSCORE;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x14634
movss 0x9b8b(%rip), %xmm0     # 0x1e1b4
movss %xmm0, 0x34(%rsp)
jmp 0x1471a
movq 0x28(%rsp), %rdi
leaq 0xb6c4(%rip), %rsi      # 0x1fd04
leaq 0x20(%rsp), %rdx
callq 0x2180
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x1470c
movq 0x18(%rsp), %rdi
leaq 0xb6a5(%rip), %rsi      # 0x1fd0c
callq 0x2280
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0xb6a7(%rip), %rsi      # 0x1fd24
callq 0x21a0
cmpl $0x0, %eax
jne 0x146ed
movl $0x0, 0xc(%rsp)
cmpl $0x2, 0xc(%rsp)
jge 0x146eb
xorl %eax, %eax
movl %eax, %edi
leaq 0xb66b(%rip), %rsi      # 0x1fd0c
callq 0x2280
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x146c3
movss 0x9af9(%rip), %xmm0     # 0x1e1b4
movss %xmm0, 0x34(%rsp)
jmp 0x1471a
cmpl $0x0, 0xc(%rsp)
je 0x146dc
movq 0x10(%rsp), %rdi
callq 0x2930
movss %xmm0, 0x34(%rsp)
jmp 0x1471a
jmp 0x146de
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1468f
jmp 0x146ed
xorl %eax, %eax
movl %eax, %edi
leaq 0xb60c(%rip), %rsi      # 0x1fd04
leaq 0x20(%rsp), %rdx
callq 0x2180
movq %rax, 0x18(%rsp)
jmp 0x1464f
movss 0x9aa0(%rip), %xmm0     # 0x1e1b4
movss %xmm0, 0x34(%rsp)
movss 0x34(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: parseCigar
int parseCigar(char* cigar, int* offset) {
  int length = 0; // length of sequence
  int pos = 0;    // position of current op in cigar
  char op;
  int len = strlen(cigar);
  for (int i = 0; i < len; i++) {
    if (cigar[i] < 0x30 || cigar[i] > 0x39) {
      op = cigar[i];
      cigar[i] = '\0';
      int opLen = getInt(cigar + pos); // length of current op
      switch (op) {
        case 'M':
        case '=':
        case 'X':
          length += opLen;
          break;
        case 'I':
        case 'S':
          length += opLen;
          *offset -= opLen;
          break;
        case 'D':
          *offset += opLen;
          break;
        case 'N':
        case 'H':
        case 'P':
          break;
        default: ;
          char msg[4] = "' '";
          msg[1] = op;
          exit(error(msg, ERRCIGAR));
      }
      pos = i + 1;
    }
  }
  return length;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x20f0
movl %eax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x14879
movq 0x30(%rsp), %rax
movslq 0x14(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0x1479c
movq 0x30(%rsp), %rax
movslq 0x14(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jle 0x14867
movq 0x30(%rsp), %rax
movslq 0x14(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, 0x1f(%rsp)
movq 0x30(%rsp), %rax
movslq 0x14(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x30(%rsp), %rdi
movslq 0x20(%rsp), %rax
addq %rax, %rdi
callq 0x2980
movl %eax, 0x10(%rsp)
movsbl 0x1f(%rsp), %eax
addl $-0x3d, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x1b, %eax
ja 0x14834
movq (%rsp), %rax
leaq 0x9a81(%rip), %rcx      # 0x1e270
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x10(%rsp), %eax
addl 0x24(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x1485c
movl 0x10(%rsp), %eax
addl 0x24(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x10(%rsp), %edx
movq 0x28(%rsp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
jmp 0x1485c
movl 0x10(%rsp), %ecx
movq 0x28(%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x1485c
jmp 0x1485c
movl 0xb4ed(%rip), %eax      # 0x1fd27
movl %eax, 0xc(%rsp)
movb 0x1f(%rsp), %al
movb %al, 0xd(%rsp)
leaq 0xc(%rsp), %rdi
movl $0x2c, %esi
callq 0x2840
movl %eax, %edi
callq 0x22b0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x14869
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x14764
movl 0x24(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: calcDist
int calcDist(char* qname, char* seq, char* cigar) {
  int length = strcmp(seq, "*") ? strlen(seq) : 0;
  int offset = 0;
  if (strcmp(cigar, "*")) {
    int len = parseCigar(cigar, &offset);
    if (! length)
      length = len;
    else if (length != len)
      exit(error(qname, ERRMISM));
  } else if (! length)
    exit(error(qname, ERRINFO));
  return length + offset;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rdi
leaq 0xad88(%rip), %rsi      # 0x1f637
callq 0x21a0
cmpl $0x0, %eax
je 0x148ca
movq 0x28(%rsp), %rdi
callq 0x20f0
movq %rax, 0x8(%rsp)
jmp 0x148d3
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x148d3
movq 0x8(%rsp), %rax
movl %eax, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x20(%rsp), %rdi
leaq 0xad47(%rip), %rsi      # 0x1f637
callq 0x21a0
cmpl $0x0, %eax
je 0x14942
movq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x14730
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x1c(%rsp)
jne 0x1491e
movl 0x14(%rsp), %eax
movl %eax, 0x1c(%rsp)
jmp 0x14940
movl 0x1c(%rsp), %eax
cmpl 0x14(%rsp), %eax
je 0x1493e
movq 0x30(%rsp), %rdi
movl $0xe, %esi
callq 0x2840
movl %eax, %edi
callq 0x22b0
jmp 0x14940
jmp 0x14961
cmpl $0x0, 0x1c(%rsp)
jne 0x1495f
movq 0x30(%rsp), %rdi
movl $0xf, %esi
callq 0x2840
movl %eax, %edi
callq 0x22b0
jmp 0x14961
movl 0x1c(%rsp), %eax
addl 0x18(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: readInt32
int32_t readInt32(gzFile in, bool end) {
  int32_t ans = 0;
  for (int i = 0; i < sizeof(int32_t); i++) {
    int m = gzgetc(in);
    if (m == -1) {
      if (end)
        exit(error("", ERRBAM));
      else
        return EOF;
    }
    ans = ans | ((m & 0xFF) << (i*8));
  }
  return ans;
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movslq 0xc(%rsp), %rax
cmpq $0x4, %rax
jae 0x1633a
movq 0x18(%rsp), %rax
cmpl $0x0, (%rax)
je 0x162c5
movq 0x18(%rsp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0x162d3
movq 0x18(%rsp), %rdi
callq 0x20a0
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0x8(%rsp)
cmpl $-0x1, 0x8(%rsp)
jne 0x1630b
testb $0x1, 0x17(%rsp)
je 0x16301
leaq 0x9a82(%rip), %rdi      # 0x1fd72
movl $0x13, %esi
callq 0x2840
movl %eax, %edi
callq 0x22b0
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x16342
movl 0x10(%rsp), %eax
movl 0x8(%rsp), %edx
andl $0xff, %edx
movl 0xc(%rsp), %ecx
shll $0x3, %ecx
shll %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movl %eax, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x16272
movl 0x10(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: loadInt32
int32_t loadInt32(char** block) {
  int32_t ans = 0;
  for (int i = 0; i < sizeof(int32_t); i++) {
    ans = ans | ((**block & 0xFF) << (i*8));
    (*block)++;
  }
  return ans;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movl $0x0, -0x10(%rsp)
movslq -0x10(%rsp), %rax
cmpq $0x4, %rax
jae 0x163b2
movl -0xc(%rsp), %eax
movq -0x8(%rsp), %rcx
movq (%rcx), %rcx
movsbl (%rcx), %edx
andl $0xff, %edx
movl -0x10(%rsp), %ecx
shll $0x3, %ecx
shll %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movl %eax, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x16365
movl -0xc(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: calcDistBAM
int calcDistBAM(int32_t l_seq, uint16_t n_cigar_op,
    uint32_t* cigar) {
  int length = l_seq;
  for (int i = 0; i < n_cigar_op; i++) {
    uint8_t op = cigar[i] & 0xF;
    uint32_t op_len = cigar[i] >> 4;
    if (op == 1 || op == 4)  // 'I' or 'S'
      length -= op_len;
    else if (op == 2)        // 'D'
      length += op_len;
  }
  return length;
}

// Assembly:
movw %si, %ax
movl %edi, -0x4(%rsp)
movw %ax, -0x6(%rsp)
movq %rdx, -0x10(%rsp)
movl -0x4(%rsp), %eax
movl %eax, -0x14(%rsp)
movl $0x0, -0x18(%rsp)
movl -0x18(%rsp), %eax
movzwl -0x6(%rsp), %ecx
cmpl %ecx, %eax
jge 0x16661
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
movl (%rax,%rcx,4), %eax
andl $0xf, %eax
movb %al, -0x19(%rsp)
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
movl (%rax,%rcx,4), %eax
shrl $0x4, %eax
movl %eax, -0x20(%rsp)
movzbl -0x19(%rsp), %eax
cmpl $0x1, %eax
je 0x1662a
movzbl -0x19(%rsp), %eax
cmpl $0x4, %eax
jne 0x1663a
movl -0x20(%rsp), %ecx
movl -0x14(%rsp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rsp)
jmp 0x16652
movzbl -0x19(%rsp), %eax
cmpl $0x2, %eax
jne 0x16650
movl -0x20(%rsp), %eax
addl -0x14(%rsp), %eax
movl %eax, -0x14(%rsp)
jmp 0x16652
jmp 0x16654
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x165e1
movl -0x14(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: arrayLen
int arrayLen(char* extra) {
  int size = 0;
  switch (extra[0]) {
    case 'c': size = sizeof(int8_t); break;
    case 'C': size = sizeof(uint8_t); break;
    case 's': size = sizeof(int16_t); break;
    case 'S': size = sizeof(uint16_t); break;
    case 'i': size = sizeof(int32_t); break;
    case 'I': size = sizeof(uint32_t); break;
    case 'f': size = sizeof(float); break;
    default: ;
      char msg[4] = "' '";
      msg[1] = extra[0];
      exit(error(msg, ERRTYPE));
  }
  extra++;
  int32_t count = loadInt32(&extra);
  return 1 + sizeof(int32_t) + size * count;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
addl $-0x43, %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x30, %eax
ja 0x166f3
movq 0x8(%rsp), %rax
leaq 0x7c3c(%rip), %rcx      # 0x1e2e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, 0x1c(%rsp)
jmp 0x1671e
movl $0x1, 0x1c(%rsp)
jmp 0x1671e
movl $0x2, 0x1c(%rsp)
jmp 0x1671e
movl $0x2, 0x1c(%rsp)
jmp 0x1671e
movl $0x4, 0x1c(%rsp)
jmp 0x1671e
movl $0x4, 0x1c(%rsp)
jmp 0x1671e
movl $0x4, 0x1c(%rsp)
jmp 0x1671e
movl 0x962e(%rip), %eax      # 0x1fd27
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movb (%rax), %al
movb %al, 0x19(%rsp)
leaq 0x18(%rsp), %rdi
movl $0x1a, %esi
callq 0x2840
movl %eax, %edi
callq 0x22b0
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x16350
movl %eax, 0x14(%rsp)
movl 0x1c(%rsp), %eax
imull 0x14(%rsp), %eax
cltq
addq $0x5, %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: loadInt
int64_t loadInt(char* block, size_t size) {
  int64_t ans = 0;
  for (int i = 0; i < size; i++)
    ans = ans | ((block[i] & 0xFF) << (i*8));
  return ans;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq $0x0, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movslq -0x1c(%rsp), %rax
cmpq -0x10(%rsp), %rax
jae 0x167b3
movq -0x18(%rsp), %rax
movq -0x8(%rsp), %rcx
movslq -0x1c(%rsp), %rdx
movsbl (%rcx,%rdx), %edx
andl $0xff, %edx
movl -0x1c(%rsp), %ecx
shll $0x3, %ecx
shll %cl, %edx
movl %edx, %ecx
movslq %ecx, %rcx
orq %rcx, %rax
movq %rax, -0x18(%rsp)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x1676b
movq -0x18(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: openWrite
void openWrite(char* outFile, File* out, bool gz) {
  if (outFile[0] == '-' && strlen(outFile) > 1)
    exit(error(outFile, ERRNAME));
  if (gz) {
    if (!strcmp(outFile + strlen(outFile) - strlen(GZEXT), GZEXT)
        || !strcmp(outFile, "/dev/null"))
      out->gzf = gzopen(outFile, "w");
    else if (!strcmp(outFile, "-"))
      out->gzf = gzdopen(fileno(stdout), "wb");
    else {
      // add ".gz" to outFile
      char* outFile2 = memalloc(strlen(outFile)
        + strlen(GZEXT) + 1);
      strcpy(outFile2, outFile);
      strcat(outFile2, GZEXT);
      out->gzf = gzopen(outFile2, "w");
      free(outFile2);
    }
    if (out->gzf == NULL)
      exit(error(outFile, ERROPENW));
  } else {
    out->f = (strcmp(outFile, "-") ?
      fopen(outFile, "w") : stdout);
    if (out->f == NULL)
      exit(error(outFile, ERROPENW));
  }
}

// Assembly:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x30(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x19179
movq 0x30(%rsp), %rdi
callq 0x20f0
cmpq $0x1, %rax
jbe 0x19179
movq 0x30(%rsp), %rdi
movl $0x2b, %esi
callq 0x2840
movl %eax, %edi
callq 0x22b0
testb $0x1, 0x27(%rsp)
je 0x192b6
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x20f0
movq 0x10(%rsp), %rdi
addq %rax, %rdi
addq $-0x3, %rdi
leaq 0x6bae(%rip), %rsi      # 0x1fd59
callq 0x21a0
cmpl $0x0, %eax
je 0x191cb
movq 0x30(%rsp), %rdi
leaq 0x6b9c(%rip), %rsi      # 0x1fd5d
callq 0x21a0
cmpl $0x0, %eax
jne 0x191ec
movq 0x30(%rsp), %rdi
leaq 0x6b90(%rip), %rsi      # 0x1fd67
callq 0x2260
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
jmp 0x19293
movq 0x30(%rsp), %rdi
leaq 0x6b71(%rip), %rsi      # 0x1fd69
callq 0x21a0
cmpl $0x0, %eax
jne 0x1922c
movq 0x9db7(%rip), %rax      # 0x22fc0
movq (%rax), %rdi
callq 0x2220
movl %eax, %edi
leaq 0x6b51(%rip), %rsi      # 0x1fd6b
callq 0x20c0
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
jmp 0x19291
movq 0x30(%rsp), %rdi
callq 0x20f0
movq %rax, %rdi
addq $0x3, %rdi
addq $0x1, %rdi
callq 0x2890
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x2070
movq 0x18(%rsp), %rdi
leaq 0x6af3(%rip), %rsi      # 0x1fd59
callq 0x2290
movq 0x18(%rsp), %rdi
leaq 0x6af0(%rip), %rsi      # 0x1fd67
callq 0x2260
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rdi
callq 0x2040
jmp 0x19293
movq 0x28(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x192b4
movq 0x30(%rsp), %rdi
movl $0x2, %esi
callq 0x2840
movl %eax, %edi
callq 0x22b0
jmp 0x19323
movq 0x30(%rsp), %rdi
leaq 0x6aa7(%rip), %rsi      # 0x1fd69
callq 0x21a0
cmpl $0x0, %eax
je 0x192e4
movq 0x30(%rsp), %rdi
leaq 0x6a8f(%rip), %rsi      # 0x1fd67
callq 0x2270
movq %rax, 0x8(%rsp)
jmp 0x192f3
movq 0x9cd5(%rip), %rax      # 0x22fc0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x19321
movq 0x30(%rsp), %rdi
movl $0x2, %esi
callq 0x2840
movl %eax, %edi
callq 0x22b0
jmp 0x19323
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: checkBAM
bool checkBAM(File in, bool gz) {
  if (! gz)
    return false;
  char magic[5] = "BAM\1";  // BAM magic string
  for (int i = 0; i < 4; i++) {
    char m = gzgetc(in.gzf);
    if (m == -1)
      exit(error("", ERROPEN));
    if (m != magic[i]) {
      // push back chars before returning false
      if (gzungetc(m, in.gzf) == -1)
        exit(error("", ERRUNGET));
      for (int j = i - 1; j > -1; j--)
        if (gzungetc(magic[j], in.gzf) == -1)
          exit(error("", ERRUNGET));
      return false;
    }
  }
  return true;
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
testb $0x1, 0x17(%rsp)
jne 0x19353
movb $0x0, 0x27(%rsp)
jmp 0x194a6
movl 0x6a15(%rip), %eax      # 0x1fd6e
movl %eax, 0x12(%rsp)
movb 0x6a0f(%rip), %al       # 0x1fd72
movb %al, 0x16(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x4, 0xc(%rsp)
jge 0x194a1
movq 0x18(%rsp), %rax
cmpl $0x0, (%rax)
je 0x193bd
movq 0x18(%rsp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, (%rsp)
jmp 0x193ca
movq 0x18(%rsp), %rdi
callq 0x20a0
movl %eax, (%rsp)
movl (%rsp), %eax
movb %al, 0xb(%rsp)
movsbl 0xb(%rsp), %eax
cmpl $-0x1, %eax
jne 0x193f3
leaq 0x6990(%rip), %rdi      # 0x1fd72
movl $0x1, %esi
callq 0x2840
movl %eax, %edi
callq 0x22b0
movsbl 0xb(%rsp), %eax
movslq 0xc(%rsp), %rcx
movsbl 0x12(%rsp,%rcx), %ecx
cmpl %ecx, %eax
je 0x1948f
movsbl 0xb(%rsp), %edi
movq 0x18(%rsp), %rsi
callq 0x20b0
cmpl $-0x1, %eax
jne 0x19436
leaq 0x694d(%rip), %rdi      # 0x1fd72
movl $0x29, %esi
callq 0x2840
movl %eax, %edi
callq 0x22b0
movl 0xc(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x4(%rsp)
cmpl $-0x1, 0x4(%rsp)
jle 0x19488
movslq 0x4(%rsp), %rax
movsbl 0x12(%rsp,%rax), %edi
movq 0x18(%rsp), %rsi
callq 0x20b0
cmpl $-0x1, %eax
jne 0x19479
leaq 0x690a(%rip), %rdi      # 0x1fd72
movl $0x29, %esi
callq 0x2840
movl %eax, %edi
callq 0x22b0
jmp 0x1947b
movl 0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x19441
movb $0x0, 0x27(%rsp)
jmp 0x194a6
jmp 0x19491
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1936f
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsh58[P]Genrich/Genrich.c
// Function: saveXChrom
int saveXChrom(char* xchrom, char*** xchrList) {
  int i = 0;
  char* chrom = strtok(xchrom, COM);
  while (chrom != NULL) {
    *xchrList = (char**) memrealloc(*xchrList,
      (i + 1) * sizeof(char*));
    (*xchrList)[i] = (char*) memalloc(1 + strlen(chrom));
    strcpy((*xchrList)[i], chrom);
    i++;
    chrom = strtok(NULL, COM);
  }
  return i;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x3559(%rip), %rsi      # 0x1fd7b
callq 0x2280
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1c8c8
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movl 0x14(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x28e0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rdi
callq 0x20f0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x2890
movq %rax, %rdx
movq 0x18(%rsp), %rax
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8(%rsp), %rsi
callq 0x2070
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x34c2(%rip), %rsi      # 0x1fd7b
callq 0x2280
movq %rax, 0x8(%rsp)
jmp 0x1c82c
movl 0x14(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/croutine.c
// Function: prvInitialiseCoRoutineLists
static void prvInitialiseCoRoutineLists( void )
{
unsigned portBASE_TYPE uxPriority;

	for( uxPriority = 0; uxPriority < configMAX_CO_ROUTINE_PRIORITIES; uxPriority++ )
	{
		vListInitialise( ( xList * ) &( pxReadyCoRoutineLists[ uxPriority ] ) );
	}

	vListInitialise( ( xList * ) &xDelayedCoRoutineList1 );
	vListInitialise( ( xList * ) &xDelayedCoRoutineList2 );
	vListInitialise( ( xList * ) &xPendingReadyCoRoutineList );

	/* Start with pxDelayedCoRoutineList using list1 and the
	pxOverflowDelayedCoRoutineList using list2. */
	pxDelayedCoRoutineList = &xDelayedCoRoutineList1;
	pxOverflowDelayedCoRoutineList = &xDelayedCoRoutineList2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, -0x8(%rbp)
cmpq $0x2, -0x8(%rbp)
jae 0x4a29
movq 0x9492(%rip), %rdi      # 0xdea0
imulq $0x28, -0x8(%rbp), %rax
addq %rax, %rdi
callq 0x43b0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x4a00
movq 0x9540(%rip), %rdi      # 0xdf70
callq 0x43b0
movq 0x9474(%rip), %rdi      # 0xdeb0
callq 0x43b0
movq 0x94d0(%rip), %rdi      # 0xdf18
callq 0x43b0
movq 0x9574(%rip), %rax      # 0xdfc8
movq 0x9515(%rip), %rcx      # 0xdf70
movq %rcx, (%rax)
movq 0x9423(%rip), %rax      # 0xde88
movq 0x9444(%rip), %rcx      # 0xdeb0
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/croutine.c
// Function: vCoRoutineAddToDelayedList
void vCoRoutineAddToDelayedList( portTickType xTicksToDelay, xList *pxEventList )
{
portTickType xTimeToWake;

	/* Calculate the time to wake - this may overflow but this is
	not a problem. */
	xTimeToWake = xCoRoutineTickCount + xTicksToDelay;

	/* We must remove ourselves from the ready list before adding
	ourselves to the blocked list as the same list item is used for
	both lists. */
	vListRemove( ( xListItem * ) &( pxCurrentCoRoutine->xGenericListItem ) );

	/* The list item will be inserted in wake time order. */
	listSET_LIST_ITEM_VALUE( &( pxCurrentCoRoutine->xGenericListItem ), xTimeToWake );

	if( xTimeToWake < xCoRoutineTickCount )
	{
		/* Wake time has overflowed.  Place this item in the
		overflow list. */
		vListInsert( ( xList * ) pxOverflowDelayedCoRoutineList, ( xListItem * ) &( pxCurrentCoRoutine->xGenericListItem ) );
	}
	else
	{
		/* The wake time has not overflowed, so we can use the
		current block list. */
		vListInsert( ( xList * ) pxDelayedCoRoutineList, ( xListItem * ) &( pxCurrentCoRoutine->xGenericListItem ) );
	}

	if( pxEventList )
	{
		/* Also add the co-routine to an event list.  If this is done then the
		function must be called with interrupts disabled. */
		vListInsert( pxEventList, &( pxCurrentCoRoutine->xEventListItem ) );
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x950a(%rip), %rax      # 0xdfa0
movl (%rax), %eax
addl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movq 0x952b(%rip), %rax      # 0xdfd0
movq (%rax), %rdi
addq $0x8, %rdi
callq 0x4040
movl -0x14(%rbp), %ecx
movq 0x9515(%rip), %rax      # 0xdfd0
movq (%rax), %rax
movl %ecx, 0x8(%rax)
movl -0x14(%rbp), %eax
movq 0x94d5(%rip), %rcx      # 0xdfa0
cmpl (%rcx), %eax
jae 0x4aee
movq 0x93b2(%rip), %rax      # 0xde88
movq (%rax), %rdi
movq 0x94f0(%rip), %rax      # 0xdfd0
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x4090
jmp 0x4b0b
movq 0x94d3(%rip), %rax      # 0xdfc8
movq (%rax), %rdi
movq 0x94d1(%rip), %rax      # 0xdfd0
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x4090
cmpq $0x0, -0x10(%rbp)
je 0x4b29
movq -0x10(%rbp), %rdi
movq 0x94b3(%rip), %rax      # 0xdfd0
movq (%rax), %rsi
addq $0x30, %rsi
callq 0x4090
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/croutine.c
// Function: prvCheckPendingReadyList
static void prvCheckPendingReadyList( void )
{
	/* Are there any co-routines waiting to get moved to the ready list?  These
	are co-routines that have been readied by an ISR.  The ISR cannot access
	the	ready lists itself. */
	while( !listLIST_IS_EMPTY( &xPendingReadyCoRoutineList ) )
	{
		corCRCB *pxUnblockedCRCB;

		/* The pending ready list can be accessed by an ISR. */
		portDISABLE_INTERRUPTS();
		{	
			pxUnblockedCRCB = ( corCRCB * ) listGET_OWNER_OF_HEAD_ENTRY( (&xPendingReadyCoRoutineList) );			
			vListRemove( &( pxUnblockedCRCB->xEventListItem ) );
		}
		portENABLE_INTERRUPTS();

		vListRemove( &( pxUnblockedCRCB->xGenericListItem ) );
		prvAddCoRoutineToReadyQueue( pxUnblockedCRCB );	
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x93d9(%rip), %rax      # 0xdf18
movq (%rax), %rax
cmpq $0x0, %rax
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4b54
jmp 0x4bf8
callq 0x4320
movq 0x93b8(%rip), %rax      # 0xdf18
movq (%rax), %rax
cmpq $0x0, %rax
je 0x4b7e
movq 0x93a8(%rip), %rax      # 0xdf18
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x4b86
xorl %eax, %eax
movq %rax, -0x10(%rbp)
jmp 0x4b86
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
callq 0x4040
callq 0x43e0
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x4040
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x93bc(%rip), %rcx      # 0xdf78
cmpq (%rcx), %rax
jbe 0x4bd3
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rcx
movq 0x93a8(%rip), %rax      # 0xdf78
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x92c2(%rip), %rdi      # 0xdea0
imulq $0x28, 0x58(%rax), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
callq 0x4760
jmp 0x4b38
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/croutine.c
// Function: vCoRoutineSchedule
void vCoRoutineSchedule( void )
{
	/* See if any co-routines readied by events need moving to the ready lists. */
	prvCheckPendingReadyList();

	/* See if any delayed co-routines have timed out. */
	prvCheckDelayedList();

	/* Find the highest priority queue that contains ready co-routines. */
	while( listLIST_IS_EMPTY( &( pxReadyCoRoutineLists[ uxTopCoRoutineReadyPriority ] ) ) )
	{
		if( uxTopCoRoutineReadyPriority == 0 )
		{
			/* No more co-routines to check. */
			return;
		}
		--uxTopCoRoutineReadyPriority;
	}

	/* listGET_OWNER_OF_NEXT_ENTRY walks through the list, so the co-routines
	 of the	same priority get an equal share of the processor time. */
	listGET_OWNER_OF_NEXT_ENTRY( pxCurrentCoRoutine, &( pxReadyCoRoutineLists[ uxTopCoRoutineReadyPriority ] ) );

	/* Call the co-routine. */
	( pxCurrentCoRoutine->pxCoRoutineFunction )( pxCurrentCoRoutine, pxCurrentCoRoutine->uxIndex );

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x41e0
callq 0x4380
movq 0x90f7(%rip), %rax      # 0xdea0
movq 0x91c8(%rip), %rcx      # 0xdf78
imulq $0x28, (%rcx), %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq $0x0, %rax
jne 0x4dec
movq 0x91b1(%rip), %rax      # 0xdf78
cmpq $0x0, (%rax)
jne 0x4dd2
jmp 0x4e7f
movq 0x919f(%rip), %rax      # 0xdf78
movq (%rax), %rcx
addq $-0x1, %rcx
movq 0x9191(%rip), %rax      # 0xdf78
movq %rcx, (%rax)
jmp 0x4da2
movq 0x90ad(%rip), %rax      # 0xdea0
movq 0x917e(%rip), %rcx      # 0xdf78
imulq $0x28, (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x4e42
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rcx
movq 0x917b(%rip), %rax      # 0xdfd0
movq %rcx, (%rax)
movq 0x9171(%rip), %rax      # 0xdfd0
movq (%rax), %rax
movq (%rax), %rax
movq 0x9164(%rip), %rcx      # 0xdfd0
movq (%rcx), %rdi
movq 0x915a(%rip), %rcx      # 0xdfd0
movq (%rcx), %rcx
movq 0x60(%rcx), %rsi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/croutine.c
// Function: xCoRoutineRemoveFromEventList
signed portBASE_TYPE xCoRoutineRemoveFromEventList( const xList *pxEventList )
{
corCRCB *pxUnblockedCRCB;
signed portBASE_TYPE xReturn;

	/* This function is called from within an interrupt.  It can only access
	event lists and the pending ready list. */
	pxUnblockedCRCB = ( corCRCB * ) listGET_OWNER_OF_HEAD_ENTRY( pxEventList );
	vListRemove( &( pxUnblockedCRCB->xEventListItem ) );
	vListInsertEnd( ( xList * ) &( xPendingReadyCoRoutineList ), &( pxUnblockedCRCB->xEventListItem ) );

	if( pxUnblockedCRCB->uxPriority >= pxCurrentCoRoutine->uxPriority )
	{
		xReturn = pdTRUE;
	}
	else
	{
		xReturn = pdFALSE;
	}

	return xReturn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, %rax
je 0x4ebb
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x4ec3
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x4ec3
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x4040
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
movq 0x9031(%rip), %rdi      # 0xdf18
callq 0x4760
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x90d5(%rip), %rcx      # 0xdfd0
movq (%rcx), %rcx
cmpq 0x58(%rcx), %rax
jb 0x4f0e
movq $0x1, -0x18(%rbp)
jmp 0x4f16
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/list.c
// Function: vListInitialise
void vListInitialise( xList *pxList )
{
	/* The list structure contains a list item which is used to mark the
	end of the list.  To initialise the list the list end is inserted
	as the only list entry. */
	pxList->pxIndex = ( xListItem * ) &( pxList->xListEnd );

	/* The list end value is the highest possible value in the list to
	ensure it remains at the end of the list. */
	pxList->xListEnd.xItemValue = portMAX_DELAY;

	/* The list end next and previous pointers point to itself so we know
	when the list is empty. */
	pxList->xListEnd.pxNext = ( xListItem * ) &( pxList->xListEnd );
	pxList->xListEnd.pxPrevious = ( xListItem * ) &( pxList->xListEnd );

	pxList->uxNumberOfItems = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
addq $0x10, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rcx
addq $0x10, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rcx
addq $0x10, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/list.c
// Function: vListInsertEnd
void vListInsertEnd( xList *pxList, xListItem *pxNewListItem )
{
volatile xListItem * pxIndex;

	/* Insert a new list item into pxList, but rather than sort the list,
	makes the new list item the last item to be removed by a call to
	pvListGetOwnerOfNextEntry.  This means it has to be the item pointed to by
	the pxIndex member. */
	pxIndex = pxList->pxIndex;

	pxNewListItem->pxNext = pxIndex->pxNext;
	pxNewListItem->pxPrevious = pxList->pxIndex;
	pxIndex->pxNext->pxPrevious = ( volatile xListItem * ) pxNewListItem;
	pxIndex->pxNext = ( volatile xListItem * ) pxNewListItem;
	pxList->pxIndex = ( volatile xListItem * ) pxNewListItem;

	/* Remember which list the item is in. */
	pxNewListItem->pvContainer = ( void * ) pxList;

	( pxList->uxNumberOfItems )++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/list.c
// Function: vListRemove
void vListRemove( xListItem *pxItemToRemove )
{
xList * pxList;

	pxItemToRemove->pxNext->pxPrevious = pxItemToRemove->pxPrevious;
	pxItemToRemove->pxPrevious->pxNext = pxItemToRemove->pxNext;
	
	/* The list item knows which list it is in.  Obtain the list from the list
	item. */
	pxList = ( xList * ) pxItemToRemove->pvContainer;

	/* Make sure the index is left pointing to a valid item. */
	if( pxList->pxIndex == pxItemToRemove )
	{
		pxList->pxIndex = pxItemToRemove->pxPrevious;
	}

	pxItemToRemove->pvContainer = NULL;
	( pxList->uxNumberOfItems )--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x511a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/queue.c
// Function: xQueueCreateMutex
xQueueHandle xQueueCreateMutex( void )
	{
	xQUEUE *pxNewQueue;

		/* Allocate the new queue structure. */
		pxNewQueue = ( xQUEUE * ) pvPortMalloc( sizeof( xQUEUE ) );
		if( pxNewQueue != NULL )
		{
			/* Information required for priority inheritance. */
			pxNewQueue->pxMutexHolder = NULL;
			pxNewQueue->uxQueueType = queueQUEUE_IS_MUTEX;

			/* Queues used as a mutex no data is actually copied into or out
			of the queue. */
			pxNewQueue->pcWriteTo = NULL;
			pxNewQueue->pcReadFrom = NULL;

			/* Each mutex has a length of 1 (like a binary semaphore) and
			an item size of 0 as nothing is actually copied into or out
			of the mutex. */
			pxNewQueue->uxMessagesWaiting = 0;
			pxNewQueue->uxLength = 1;
			pxNewQueue->uxItemSize = 0;
			pxNewQueue->xRxLock = queueUNLOCKED;
			pxNewQueue->xTxLock = queueUNLOCKED;

			/* Ensure the event queues start with the correct state. */
			vListInitialise( &( pxNewQueue->xTasksWaitingToSend ) );
			vListInitialise( &( pxNewQueue->xTasksWaitingToReceive ) );

			/* Start with the semaphore in the expected state. */
			xQueueGenericSend( pxNewQueue, NULL, 0, queueSEND_TO_BACK );

			traceCREATE_MUTEX( pxNewQueue );
		}
		else
		{
			traceCREATE_MUTEX_FAILED();
		}

		return pxNewQueue;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x98, %edi
callq 0x42f0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5343
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x8(%rbp), %rax
movq $0x1, 0x78(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x80(%rax)
movq -0x8(%rbp), %rax
movq $-0x1, 0x88(%rax)
movq -0x8(%rbp), %rax
movq $-0x1, 0x90(%rax)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x43b0
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
callq 0x43b0
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
xorl %edx, %edx
movq %rcx, %rsi
callq 0x4520
jmp 0x5345
jmp 0x5345
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/queue.c
// Function: xQueueTakeMutexRecursive
portBASE_TYPE xQueueTakeMutexRecursive( xQueueHandle pxMutex, portTickType xBlockTime )
	{
	portBASE_TYPE xReturn;

		/* Comments regarding mutual exclusion as per those within
		xQueueGiveMutexRecursive(). */

		traceTAKE_MUTEX_RECURSIVE( pxMutex );

		if( pxMutex->pxMutexHolder == xTaskGetCurrentTaskHandle() )
		{
			( pxMutex->uxRecursiveCallCount )++;
			xReturn = pdPASS;
		}
		else
		{
			xReturn = xQueueGenericReceive( pxMutex, NULL, xBlockTime, pdFALSE );

			/* pdPASS will only be returned if we successfully obtained the mutex,
			we may have blocked to reach here. */
			if( xReturn == pdPASS )
			{
				( pxMutex->uxRecursiveCallCount )++;
			}
		}

		return xReturn;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x40c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jne 0x55b6
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq $0x1, -0x18(%rbp)
jmp 0x55e6
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rsi
callq 0x4280
movq %rax, -0x18(%rbp)
cmpq $0x1, -0x18(%rbp)
jne 0x55e4
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
jmp 0x55e6
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/queue.c
// Function: xQueueCreateCountingSemaphore
xQueueHandle xQueueCreateCountingSemaphore( unsigned portBASE_TYPE uxCountValue, unsigned portBASE_TYPE uxInitialCount )
	{
	xQueueHandle pxHandle;

		pxHandle = xQueueCreate( ( unsigned portBASE_TYPE ) uxCountValue, queueSEMAPHORE_QUEUE_ITEM_LENGTH );

		if( pxHandle != NULL )
		{
			pxHandle->uxMessagesWaiting = uxInitialCount;

			traceCREATE_COUNTING_SEMAPHORE();
		}
		else
		{
			traceCREATE_COUNTING_SEMAPHORE_FAILED();
		}

		return pxHandle;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4150
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5856
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x70(%rax)
jmp 0x5858
jmp 0x5858
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)