LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/iseq2comem.c
// Function: write_fqkoc2file
llong write_fqkoc2file(char* cofilename, llong *co)
{
  int comp_code_bits = half_ctx_len - drlevel > COMPONENT_SZ ? 4*(half_ctx_len - drlevel - COMPONENT_SZ ) : 0 ;
  FILE **outf;
  outf = malloc(component_num * sizeof(FILE *));
  char cofilename_with_component[PATHLEN];
  for(int i=0;i<component_num ;i++)
  {
    sprintf(cofilename_with_component,"%s.%d",cofilename,i);
    if ( (outf[i] = fopen(cofilename_with_component,"wb") ) == NULL )
      err(errno,"write_fqkoc2file()") ;
  };
  unsigned int count, wr = 0;
 llong newid;
  for(count=0;count < hashsize; count++)
  {
    if( co[count] > 0 ) {
   newid = ((co[count] >> (comp_code_bits + OCCRC_BIT)) << OCCRC_BIT ) | (co[count] & OCCRC_MAX) ;
      fwrite( &newid, sizeof(llong),1,outf[ (co[count] >> OCCRC_BIT ) % component_num ] );
      wr++;
    }
  }
  for(int i=0;i<component_num ;i++)
    fclose(outf[i]);
 free(outf);
  return wr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rsi, 0x10(%rsp)
movl 0x4ae77(%rip), %eax     # 0x5e618
subl 0x4ae7d(%rip), %eax     # 0x5e624
movq %rdi, %r12
cmpl $0x8, %eax
leal -0xc(,%rax,4), %eax
movl $0x10, %ecx
cmovgel %eax, %ecx
movq %rcx, 0x8(%rsp)
movslq 0x4ae68(%rip), %r14     # 0x5e630
leaq (,%r14,8), %rdi
callq 0x3340
movq %rax, %rbx
testq %r14, %r14
jle 0x1382d
leaq 0x187d(%rip), %r13      # 0x15061
leaq 0x20(%rsp), %rbp
leaq 0x187a(%rip), %r15      # 0x1506a
xorl %r14d, %r14d
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movl %r14d, %ecx
xorl %eax, %eax
callq 0x3430
movq %rbp, %rdi
movq %r15, %rsi
callq 0x33a0
movq %rax, (%rbx,%r14,8)
testq %rax, %rax
je 0x138e6
incq %r14
movslq 0x4ae08(%rip), %rax     # 0x5e630
cmpq %rax, %r14
jl 0x137f3
xorl %r12d, %r12d
cmpl $0x0, 0x4adf1(%rip)     # 0x5e628
je 0x138a5
leaq 0x18(%rsp), %r13
xorl %r14d, %r14d
movq 0x10(%rsp), %r15
movq 0x8(%rsp), %rbp
movq (%r15,%r14,8), %rax
testq %rax, %rax
je 0x13894
movq %rax, %rdx
movl %ebp, %ecx
shrq %cl, %rdx
shlq $0x10, %rdx
movzwl %ax, %ecx
orq %rdx, %rcx
movq %rcx, 0x18(%rsp)
shrq $0x10, %rax
movslq 0x4adba(%rip), %rcx     # 0x5e630
xorl %edx, %edx
divq %rcx
movq (%rbx,%rdx,8), %rcx
movl $0x8, %esi
movl $0x1, %edx
movq %r13, %rdi
callq 0x3450
incl %r12d
incq %r14
movl 0x4ad8b(%rip), %eax     # 0x5e628
cmpq %rax, %r14
jb 0x1384b
movl %r12d, %r12d
cmpl $0x0, 0x4ad84(%rip)     # 0x5e630
jle 0x138c9
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rdi
callq 0x3100
incq %r14
movslq 0x4ad6c(%rip), %rax     # 0x5e630
cmpq %rax, %r14
jl 0x138b1
movq %rbx, %rdi
callq 0x3040
movq %r12, %rax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3060
movl (%rax), %edi
leaq 0x49c1(%rip), %rsi      # 0x182b5
xorl %eax, %eax
callq 0x3330
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/iseq2comem.c
// Function: write_fqco2file
llong write_fqco2file(char* cofilename, llong *co)
{
 int comp_code_bits = half_ctx_len - drlevel > COMPONENT_SZ ? 4*(half_ctx_len - drlevel - COMPONENT_SZ ) : 0 ;
 FILE **outf;
 outf = malloc(component_num * sizeof(FILE *));
 char cofilename_with_component[PATHLEN];
 for(int i=0;i<component_num ;i++)
  {
    sprintf(cofilename_with_component,"%s.%d",cofilename,i);
    if ( (outf[i] = fopen(cofilename_with_component,"wb") ) == NULL )
      err(errno,"write_fqco2file()") ;
  };
 unsigned int count, wr = 0, newid;
 for(count=0;count < hashsize; count++)
 {
  if( (co[count] & CT_MAX) == CT_MAX ) {
   newid = (unsigned int)( co[count] >> (comp_code_bits + CT_BIT) ) ;
   fwrite( &newid, sizeof(unsigned int),1,outf[(int)( (co[count] >> CT_BIT ) % component_num )] );
      wr++;
  }
 }
 for(int i=0;i<component_num ;i++)
   fclose(outf[i]);
 free(outf);
 return wr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rsi, 0x18(%rsp)
movl 0x4ad01(%rip), %eax     # 0x5e618
subl 0x4ad07(%rip), %eax     # 0x5e624
movq %rdi, %r12
cmpl $0x8, %eax
leal -0x18(,%rax,4), %eax
movl $0x4, %ecx
cmovgel %eax, %ecx
movq %rcx, 0x10(%rsp)
movslq 0x4acf2(%rip), %r14     # 0x5e630
leaq (,%r14,8), %rdi
callq 0x3340
movq %rax, %rbx
testq %r14, %r14
jle 0x139a3
leaq 0x1707(%rip), %r13      # 0x15061
leaq 0x20(%rsp), %rbp
leaq 0x1704(%rip), %r15      # 0x1506a
xorl %r14d, %r14d
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movl %r14d, %ecx
xorl %eax, %eax
callq 0x3430
movq %rbp, %rdi
movq %r15, %rsi
callq 0x33a0
movq %rax, (%rbx,%r14,8)
testq %rax, %rax
je 0x13a58
incq %r14
movslq 0x4ac92(%rip), %rax     # 0x5e630
cmpq %rax, %r14
jl 0x13969
xorl %r12d, %r12d
cmpl $0x0, 0x4ac7b(%rip)     # 0x5e628
je 0x13a17
leaq 0xc(%rsp), %r13
xorl %r14d, %r14d
movq 0x18(%rsp), %r15
movq 0x10(%rsp), %rbp
movq (%r15,%r14,8), %rax
movl %eax, %ecx
notl %ecx
testb $0xf, %cl
jne 0x13a06
movq %rax, %rdx
movl %ebp, %ecx
shrq %cl, %rdx
movl %edx, 0xc(%rsp)
shrq $0x4, %rax
movslq 0x4ac4b(%rip), %rcx     # 0x5e630
xorl %edx, %edx
divq %rcx
movslq %edx, %rax
movq (%rbx,%rax,8), %rcx
movl $0x4, %esi
movl $0x1, %edx
movq %r13, %rdi
callq 0x3450
incl %r12d
incq %r14
movl 0x4ac19(%rip), %eax     # 0x5e628
cmpq %rax, %r14
jb 0x139c1
movl %r12d, %r12d
cmpl $0x0, 0x4ac12(%rip)     # 0x5e630
jle 0x13a3b
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rdi
callq 0x3100
incq %r14
movslq 0x4abfa(%rip), %rax     # 0x5e630
cmpq %rax, %r14
jl 0x13a23
movq %rbx, %rdi
callq 0x3040
movq %r12, %rax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3060
movl (%rax), %edi
leaq 0x4862(%rip), %rsi      # 0x182c8
xorl %eax, %eax
callq 0x3330
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/iseq2comem.c
// Function: wrt_co2cmpn_use_inn_subctx
llong wrt_co2cmpn_use_inn_subctx(char* cofilename, llong *co)
{
 int comp_code_bits = half_ctx_len - drlevel > COMPONENT_SZ ? 4*(half_ctx_len - drlevel - COMPONENT_SZ ) : 0 ;
 FILE **outf;
 outf = malloc(component_num * sizeof(FILE *));
 char cofilename_with_component[PATHLEN];
  for(int i=0;i<component_num ;i++)
  {
    sprintf(cofilename_with_component,"%s.%d",cofilename,i);
    if ( (outf[i] = fopen(cofilename_with_component,"wb") ) == NULL )
      err(errno,"wrt_co2cmpn_use_inn_subctx()") ;
  };
  unsigned int count, wr = 0, newid;
 for(count=0;count < hashsize; count++)
 {
  if( co[count] != 0 && co[count] < HIBITSET1 )
  {
   newid = (unsigned int)( co[count] >> comp_code_bits ) ;
   fwrite( &newid, sizeof(unsigned int),1,outf[(int)( co[count] % component_num )] );
   wr++;
  }
 }
 for(int i=0;i<component_num ;i++)
   fclose(outf[i]);
 free(outf);
  return wr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rsi, 0x18(%rsp)
movl 0x4ab8f(%rip), %eax     # 0x5e618
subl 0x4ab95(%rip), %eax     # 0x5e624
movq %rdi, %r12
xorl %ecx, %ecx
cmpl $0x8, %eax
leal -0x1c(,%rax,4), %eax
cmovll %ecx, %eax
movq %rax, 0x10(%rsp)
movslq 0x4ab83(%rip), %r14     # 0x5e630
leaq (,%r14,8), %rdi
callq 0x3340
movq %rax, %rbx
testq %r14, %r14
jle 0x13b12
leaq 0x1598(%rip), %r13      # 0x15061
leaq 0x20(%rsp), %rbp
leaq 0x1595(%rip), %r15      # 0x1506a
xorl %r14d, %r14d
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movl %r14d, %ecx
xorl %eax, %eax
callq 0x3430
movq %rbp, %rdi
movq %r15, %rsi
callq 0x33a0
movq %rax, (%rbx,%r14,8)
testq %rax, %rax
je 0x13bbf
incq %r14
movslq 0x4ab23(%rip), %rax     # 0x5e630
cmpq %rax, %r14
jl 0x13ad8
xorl %r12d, %r12d
cmpl $0x0, 0x4ab0c(%rip)     # 0x5e628
je 0x13b7e
leaq 0xc(%rsp), %r13
xorl %r14d, %r14d
movq 0x18(%rsp), %r15
movq 0x10(%rsp), %rbp
movq (%r15,%r14,8), %rax
testq %rax, %rax
jle 0x13b6d
movq %rax, %rdx
movl %ebp, %ecx
shrq %cl, %rdx
movl %edx, 0xc(%rsp)
movslq 0x4aae4(%rip), %rcx     # 0x5e630
xorl %edx, %edx
divq %rcx
movslq %edx, %rax
movq (%rbx,%rax,8), %rcx
movl $0x4, %esi
movl $0x1, %edx
movq %r13, %rdi
callq 0x3450
incl %r12d
incq %r14
movl 0x4aab2(%rip), %eax     # 0x5e628
cmpq %rax, %r14
jb 0x13b30
movl %r12d, %r12d
cmpl $0x0, 0x4aaab(%rip)     # 0x5e630
jle 0x13ba2
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rdi
callq 0x3100
incq %r14
movslq 0x4aa93(%rip), %rax     # 0x5e630
cmpq %rax, %r14
jl 0x13b8a
movq %rbx, %rdi
callq 0x3040
movq %r12, %rax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3060
movl (%rax), %edi
leaq 0x470d(%rip), %rsi      # 0x182da
xorl %eax, %eax
callq 0x3330
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/kssd.c
// Function: main
int main(int argc, char** argv)
{
  setvbuf(stdout, (char *)NULL, _IOLBF, 0);
  setvbuf(stderr, (char *)NULL, _IOLBF, 0);
 const char subcommand_n[] = "<subcommand>";
  domain = (char*) malloc(strlen(argv[0])+1);
  strcpy(domain,argv[0]);
  long_domain = (char*) malloc( strlen(domain) + strlen(subcommand_n) + 1);
  snprintf(long_domain,strlen(domain) + strlen(subcommand_n) + 2,"%s %s",domain,subcommand_n);
  cmd_global(argc, argv);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl %edi, %ebp
movq 0x7c24(%rip), %rax      # 0x1bfd8
movq (%rax), %rdi
xorl %esi, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x3370
movq 0x7c2c(%rip), %rax      # 0x1bff8
movq (%rax), %rdi
xorl %esi, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x3370
movabsq $0x3e646e616d6d6f, %rax # imm = 0x3E646E616D6D6F
movq %rsp, %r14
movq %rax, 0x5(%r14)
movabsq $0x6d6d6f636275733c, %rax # imm = 0x6D6D6F636275733C
movq %rax, (%r14)
movq (%rbx), %rdi
callq 0x3130
leaq 0x1(%rax), %rdi
callq 0x3340
movq %rax, %r15
leaq 0x4a1ea(%rip), %rax     # 0x5e600
movq %r15, (%rax)
movq (%rbx), %rsi
movq %r15, %rdi
callq 0x3080
movq %r15, %rdi
callq 0x3130
movq %rax, %r12
leaq 0xd(%rax), %rdi
callq 0x3340
leaq 0x4a1c9(%rip), %rcx     # 0x5e608
movq %rax, (%rcx)
addq $0xe, %r12
leaq 0x3cd7(%rip), %rdx      # 0x18124
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rcx
movq %r14, %r8
xorl %eax, %eax
callq 0x31b0
movl %ebp, %edi
movq %rbx, %rsi
callq 0x121c8
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/yhg926[P]public_kssd/mytime.c
// Function: diff
struct timespec diff(struct timespec start, struct timespec end)
{
        struct timespec temp;
        if ((end.tv_nsec - start.tv_nsec) < 0)
        {
                temp.tv_sec = end.tv_sec - start.tv_sec - 1;
                temp.tv_nsec = 1000000000 + end.tv_nsec - start.tv_nsec;
        }
        else
        {
                temp.tv_sec = end.tv_sec - start.tv_sec;
                temp.tv_nsec = end.tv_nsec - start.tv_nsec;
        }
        return temp;
}

// Assembly:
movq %rdx, %r8
movq %rdi, %rax
movq %rcx, %rdx
subq %rsi, %rdx
js 0x144f2
subq %rax, %r8
movq %r8, %rax
retq
notq %rax
addq %r8, %rax
subq %rsi, %rcx
addq $0x3b9aca00, %rcx       # imm = 0x3B9ACA00
movq %rcx, %rdx
retq
// File: /workspace/github_c_makefile_star2_O1/mgrosvenor[P]evec/demo1.c
// Function: main
int main(int argc, char** argv)
{
    int* a = NULL;
    evpsh(a, 2);
    evpsh(a, 4);
    evpsh(a, 6);

    for(int i =0; i < evcnt(a); i++){
        printf("%i: %i\n", i, a[i]);
    }

    a = evfree(a);
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %rsi
movl $0x2, (%rsi)
movl $0x4, %edx
xorl %edi, %edi
callq 0x1656
leaq 0x8(%rsp), %rsi
movl $0x4, (%rsi)
movl $0x4, %edx
movq %rax, %rdi
callq 0x1656
leaq 0x4(%rsp), %rsi
movl $0x6, (%rsi)
movl $0x4, %edx
movq %rax, %rdi
callq 0x1656
movq %rax, %rbx
movq %rax, %rdi
callq 0x1725
testq %rax, %rax
je 0x19f6
leaq 0x9ae(%rip), %r14       # 0x2380
xorl %r15d, %r15d
movl (%rbx,%r15,4), %edx
movq %r14, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x1050
incq %r15
movq %rbx, %rdi
callq 0x1725
cmpq %r15, %rax
ja 0x19d5
movq %rbx, %rdi
callq 0x1925
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/CkTD[P]btree/btree_test2.c
// Function: main
int main()
{
    uint64_t       k, n;
    BTree         *bt;
    BTreeOpenFlag  flag;
    BTreeValues   *values;

    
    flag.create_if_missing = 1;
    flag.error_if_exist = 0;
    flag.file = "./test.bt";
    flag.order = 501;

    bt = bt_open(flag);
    //bt_print(bt);

    n = 544;

    printf("插入1000000个随机的 key/value pair...");
    for(k=0;k<1000000;k++)
    {
        n = rand() % 1000000;
        bt_insert(bt, n, n);
        if(n<10)
        {
            printf("\tinsert (%ld, %ld)\n", n, n);
        }
        //bt_insert(bt, rand(), rand());
        //bt_print(bt);
    }
    printf("Insert done.\n");
    
    printf("搜索 [0, 10] 范围的 key...\n");
    values = bt_search_range(bt, 100, 0, 10);
    printf("\tSearch Result[%lu]: ", bt_values_get_count(values));
    for(k=0;k<bt_values_get_count(values); k++)
        printf("%lu ", bt_values_get_value(values, k));
    printf("\n");
    bt_values_destory(values);

    printf("Search done.\n");
    bt_close(bt);
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq $0x1, 0x30(%rsp)
leaq 0x11ff(%rip), %rax      # 0x393e
movq %rax, 0x20(%rsp)
movq $0x1f5, 0x28(%rsp)      # imm = 0x1F5
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x18c3
movq %rax, %rbx
leaq 0x11d9(%rip), %rdi      # 0x3948
xorl %eax, %eax
callq 0x1090
movl $0xf4240, %r12d         # imm = 0xF4240
leaq 0x11f1(%rip), %r14      # 0x3974
callq 0x1140
cltq
imulq $0x431bde83, %rax, %rcx # imm = 0x431BDE83
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x32, %rcx
addl %edx, %ecx
imull $0xf4240, %ecx, %ecx    # imm = 0xF4240
subl %ecx, %eax
movslq %eax, %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r15, %rdx
callq 0x163f
cmpl $0x9, %r15d
ja 0x27cd
movq %r14, %rdi
movq %r15, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1090
decq %r12
jne 0x2783
leaq 0x11c5(%rip), %rdi      # 0x399e
callq 0x1060
leaq 0x11c6(%rip), %rdi      # 0x39ab
callq 0x1060
movl $0x64, %esi
movl $0xa, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x182c
movq %rax, %r14
movq %rax, %rdi
callq 0x1501
leaq 0x1178(%rip), %rdi      # 0x3988
movq %rax, %rsi
xorl %eax, %eax
callq 0x1090
movq %r14, %rdi
callq 0x1501
testq %rax, %rax
je 0x2859
leaq 0xa89(%rip), %r15       # 0x32b7
xorl %r12d, %r12d
movq %r14, %rdi
movq %r12, %rsi
callq 0x1505
movq %r15, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x1090
incq %r12
movq %r14, %rdi
callq 0x1501
cmpq %rax, %r12
jb 0x2831
movl $0xa, %edi
callq 0x1040
movq %r14, %rdi
callq 0x14eb
leaq 0x1159(%rip), %rdi      # 0x39cb
callq 0x1060
movq %rbx, %rdi
callq 0x1b82
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lyda[P]tz/zdump.c
// Function: yeartot
static time_t
yeartot(y)
const long	y;
{
	register long	myy;
	register long	seconds;
	register time_t	t;

	myy = EPOCH_YEAR;
	t = 0;
	while (myy != y) {
		if (myy < y) {
			seconds = isleap(myy) ? SECSPERLYEAR : SECSPERNYEAR;
			++myy;
			if (t > absolute_max_time - seconds) {
				t = absolute_max_time;
				break;
			}
			t += seconds;
		} else {
			--myy;
			seconds = isleap(myy) ? SECSPERLYEAR : SECSPERNYEAR;
			if (t < absolute_min_time + seconds) {
				t = absolute_min_time;
				break;
			}
			t -= seconds;
		}
	}
	return t;
}

// Assembly:
cmpq $0x7b2, %rdi            # imm = 0x7B2
jne 0x2cb4
xorl %eax, %eax
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
leaq 0x1(%rcx), %rdx
xorl %eax, %eax
cmpb $0x0, 0x58c6(%rip)      # 0x8598
cmoveq %rax, %rdx
cmpb $0x0, 0x58c3(%rip)      # 0x85a0
cmoveq %rax, %rcx
movl $0x7b2, %esi            # imm = 0x7B2
movabsq $-0x70a3d70a3d70a3d7, %r8 # imm = 0x8F5C28F5C28F5C29
movabsq $0x51eb851eb851eb8, %r9 # imm = 0x51EB851EB851EB8
movabsq $0x28f5c28f5c28f5c, %r10 # imm = 0x28F5C28F5C28F5C
movabsq $0x51eb851eb851eb0, %r11 # imm = 0x51EB851EB851EB0
movabsq $0xa3d70a3d70a3d7, %rbx # imm = 0xA3D70A3D70A3D7
cmpq %rdi, %rsi
jge 0x2d68
movl $0x1e13380, %r14d       # imm = 0x1E13380
testb $0x3, %sil
jne 0x2d55
movq %rsi, %r15
imulq %r8, %r15
leaq (%r15,%r9), %r12
rorq $0x2, %r12
movl $0x1e28500, %r14d       # imm = 0x1E28500
cmpq %r10, %r12
ja 0x2d55
addq %r11, %r15
rorq $0x4, %r15
cmpq %rbx, %r15
jb 0x2d55
movl $0x1e13380, %r14d       # imm = 0x1E13380
movq %rcx, %r15
subq %r14, %r15
cmpq %r15, %rax
jg 0x2dc1
incq %rsi
addq %r14, %rax
jmp 0x2db1
decq %rsi
movl $0x1e13380, %r14d       # imm = 0x1E13380
testb $0x3, %sil
jne 0x2da3
movq %rsi, %r15
imulq %r8, %r15
leaq (%r15,%r9), %r12
rorq $0x2, %r12
movl $0x1e28500, %r14d       # imm = 0x1E28500
cmpq %r10, %r12
ja 0x2da3
addq %r11, %r15
rorq $0x4, %r15
cmpq %rbx, %r15
jb 0x2da3
movl $0x1e13380, %r14d       # imm = 0x1E13380
movq %rdx, %r15
orq %r14, %r15
cmpq %r15, %rax
jl 0x2dbc
subq %r14, %rax
cmpq %rdi, %rsi
jne 0x2d18
jmp 0x2dc4
movq %rdx, %rax
jmp 0x2dc4
movq %rcx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lyda[P]tz/zdump.c
// Function: delta
static long
delta(newp, oldp)
struct tm *	newp;
struct tm *	oldp;
{
	register long	result;
	register int	tmy;

	if (newp->tm_year < oldp->tm_year)
		return -delta(oldp, newp);
	result = 0;
	for (tmy = oldp->tm_year; tmy < newp->tm_year; ++tmy)
		result += DAYSPERNYEAR + isleap_sum(tmy, TM_YEAR_BASE);
	result += newp->tm_yday - oldp->tm_yday;
	result *= HOURSPERDAY;
	result += newp->tm_hour - oldp->tm_hour;
	result *= MINSPERHOUR;
	result += newp->tm_min - oldp->tm_min;
	result *= SECSPERMIN;
	result += newp->tm_sec - oldp->tm_sec;
	return result;
}

// Assembly:
movq %rdi, %rax
movl 0x14(%rdi), %edx
movl 0x14(%rsi), %edi
cmpl %edi, %edx
jge 0x3060
pushq %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x303f
negq %rax
addq $0x8, %rsp
retq
jle 0x30ef
xorl %ecx, %ecx
movslq %edi, %r10
imulq $0x51eb851f, %r10, %r8  # imm = 0x51EB851F
movq %r8, %r9
shrq $0x3f, %r9
sarq $0x27, %r8
addl %r9d, %r8d
imull $0x190, %r8d, %r9d      # imm = 0x190
subl %r9d, %r10d
movl $0x16d, %r8d            # imm = 0x16D
testb $0x3, %r10b
jne 0x30e0
negl %r9d
leal (%rdi,%r9), %r8d
addl $0x12c, %r8d            # imm = 0x12C
imull $0xc28f5c29, %r8d, %r9d # imm = 0xC28F5C29
addl $0x51eb850, %r9d        # imm = 0x51EB850
movl %r9d, %r10d
rorl $0x2, %r10d
movl $0x16e, %r8d            # imm = 0x16E
cmpl $0x28f5c28, %r10d       # imm = 0x28F5C28
ja 0x30e0
rorl $0x4, %r9d
cmpl $0xa3d70b, %r9d         # imm = 0xA3D70B
movl $0x0, %r8d
adcq $0x16d, %r8             # imm = 0x16D
addq %r8, %rcx
incl %edi
cmpl %edi, %edx
jne 0x3068
jmp 0x30f1
xorl %ecx, %ecx
movslq 0x1c(%rax), %rdx
movslq 0x1c(%rsi), %rdi
subq %rdi, %rdx
addq %rcx, %rdx
leaq (%rdx,%rdx,2), %rcx
movslq 0x8(%rax), %rdx
movslq 0x8(%rsi), %rdi
subq %rdi, %rdx
leaq (%rdx,%rcx,8), %rcx
imulq $0x3c, %rcx, %rcx
movslq 0x4(%rax), %rdx
movslq 0x4(%rsi), %rdi
subq %rdi, %rdx
addq %rcx, %rdx
imulq $0x3c, %rdx, %rcx
movslq (%rax), %rax
movslq (%rsi), %rdx
subq %rdx, %rax
addq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/lyda[P]tz/zdump.c
// Function: dumptime
static void
dumptime(timeptr)
register const struct tm *	timeptr;
{
	static const char	wday_name[][3] = {
		"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
	};
	static const char	mon_name[][3] = {
		"Jan", "Feb", "Mar", "Apr", "May", "Jun",
		"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
	};
	register const char *	wn;
	register const char *	mn;
	register int		lead;
	register int		trail;

	if (timeptr == NULL) {
		(void) printf("NULL");
		return;
	}
	/*
	** The packaged versions of localtime and gmtime never put out-of-range
	** values in tm_wday or tm_mon, but since this code might be compiled
	** with other (perhaps experimental) versions, paranoia is in order.
	*/
	if (timeptr->tm_wday < 0 || timeptr->tm_wday >=
		(int) (sizeof wday_name / sizeof wday_name[0]))
			wn = "???";
	else		wn = wday_name[timeptr->tm_wday];
	if (timeptr->tm_mon < 0 || timeptr->tm_mon >=
		(int) (sizeof mon_name / sizeof mon_name[0]))
			mn = "???";
	else		mn = mon_name[timeptr->tm_mon];
	(void) printf("%.3s %.3s%3d %.2d:%.2d:%.2d ",
		wn, mn,
		timeptr->tm_mday, timeptr->tm_hour,
		timeptr->tm_min, timeptr->tm_sec);
#define DIVISOR	10
	trail = timeptr->tm_year % DIVISOR + TM_YEAR_BASE % DIVISOR;
	lead = timeptr->tm_year / DIVISOR + TM_YEAR_BASE / DIVISOR +
		trail / DIVISOR;
	trail %= DIVISOR;
	if (trail < 0 && lead > 0) {
		trail += DIVISOR;
		--lead;
	} else if (lead < 0 && trail > 0) {
		trail -= DIVISOR;
		++lead;
	}
	if (lead == 0)
		(void) printf("%d", trail);
	else	(void) printf("%d%d", lead, ((trail < 0) ? -trail : trail));
}

// Assembly:
testq %rdi, %rdi
je 0x31e3
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x18(%rdi), %eax
leaq (%rax,%rax,2), %rcx
leaq 0x307c(%rip), %rsi      # 0x61d0
addq %rcx, %rsi
cmpq $0x7, %rax
leaq 0x2fa6(%rip), %rax      # 0x6108
cmovaeq %rax, %rsi
movl 0x10(%rdi), %ecx
leaq (%rcx,%rcx,2), %rdi
leaq 0x307c(%rip), %rdx      # 0x61f0
addq %rdi, %rdx
cmpq $0xc, %rcx
cmovaeq %rax, %rdx
movl 0xc(%rbx), %ecx
movl 0x8(%rbx), %r8d
movl (%rbx), %eax
movl 0x4(%rbx), %r9d
movl %eax, (%rsp)
leaq 0x2f76(%rip), %rdi      # 0x610c
xorl %eax, %eax
callq 0x20f0
movslq 0x14(%rbx), %rcx
cmpq $-0x76b, %rcx           # imm = 0xF895
setl %dl
imulq $0x66666667, %rcx, %rsi # imm = 0x66666667
movq %rsi, %rax
shrq $0x3f, %rax
sarq $0x22, %rsi
addl %eax, %esi
leal (%rsi,%rsi), %eax
leal (%rax,%rax,4), %edi
movl %ecx, %eax
subl %edi, %eax
setns %dil
orb %dl, %dil
leaq 0x10(%rsp), %rsp
popq %rbx
jne 0x31f1
addl $0xa, %eax
addl $0xbd, %esi
jmp 0x3214
leaq 0x2f19(%rip), %rdi      # 0x6103
xorl %eax, %eax
jmp 0x20f0
cmpl $0xfffff88b, %ecx       # imm = 0xFFFFF88B
setge %cl
testl %eax, %eax
setle %dl
orb %cl, %dl
jne 0x320e
addl $-0xa, %eax
addl $0xbf, %esi
jmp 0x3214
addl $0xbe, %esi
testl %esi, %esi
je 0x322d
movl %eax, %edx
negl %edx
cmovsl %eax, %edx
leaq 0x2f03(%rip), %rdi      # 0x6129
xorl %eax, %eax
jmp 0x20f0
leaq 0x2ec8(%rip), %rdi      # 0x60fc
movl %eax, %esi
xorl %eax, %eax
jmp 0x20f0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/lyda[P]tz/localtime.c
// Function: tzset
void
tzset(void)
{
	register const char *	name;

	name = getenv("TZ");
	if (name == NULL) {
		tzsetwall();
		return;
	}

	if (lcl_is_set > 0 && strcmp(lcl_TZname, name) == 0)
		return;
	lcl_is_set = strlen(name) < sizeof lcl_TZname;
	if (lcl_is_set)
		(void) strcpy(lcl_TZname, name);

#ifdef ALL_STATE
	if (lclptr == NULL) {
		lclptr = (struct state *) calloc(1, sizeof *lclptr);
		if (lclptr == NULL) {
			settzname();	/* all we can do */
			return;
		}
	}
#endif /* defined ALL_STATE */
	if (*name == '\0') {
		/*
		** User wants it fast rather than right.
		*/
		lclptr->leapcnt = 0;		/* so, we're off a little */
		lclptr->timecnt = 0;
		lclptr->typecnt = 0;
		lclptr->ttis[0].tt_isdst = 0;
		lclptr->ttis[0].tt_gmtoff = 0;
		lclptr->ttis[0].tt_abbrind = 0;
		(void) strcpy(lclptr->chars, gmt);
	} else if (tzload(name, lclptr, TRUE) != 0)
		if (name[0] == ':' || tzparse(name, lclptr, FALSE) != 0)
			(void) gmtload(lclptr);
	settzname();
}

// Assembly:
pushq %rbx
leaq 0x2fe0(%rip), %rdi      # 0x6228
callq 0x2030
movq %rax, %rbx
movl 0x535a(%rip), %eax      # 0x85b0
testq %rbx, %rbx
je 0x32d5
testl %eax, %eax
jle 0x3276
leaq 0x535a(%rip), %rdi      # 0x85c0
movq %rbx, %rsi
callq 0x2150
testl %eax, %eax
je 0x3308
movq %rbx, %rdi
callq 0x20c0
xorl %ecx, %ecx
cmpq $0x100, %rax            # imm = 0x100
setb %cl
movl %ecx, 0x5321(%rip)      # 0x85b0
jae 0x32a0
leaq 0x5328(%rip), %rdi      # 0x85c0
movq %rbx, %rsi
callq 0x2090
cmpb $0x0, (%rbx)
je 0x330a
leaq 0x5414(%rip), %rsi      # 0x86c0
movq %rbx, %rdi
movl $0x1, %edx
callq 0x3339
testl %eax, %eax
je 0x3333
cmpb $0x3a, (%rbx)
je 0x32fa
leaq 0x53f7(%rip), %rsi      # 0x86c0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3cee
jmp 0x32f6
testl %eax, %eax
js 0x3308
movl $0xffffffff, 0x52cd(%rip) # imm = 0xFFFFFFFF
leaq 0x53d6(%rip), %rsi      # 0x86c0
xorl %edi, %edi
movl $0x1, %edx
callq 0x3339
testl %eax, %eax
je 0x3333
leaq 0x53bf(%rip), %rdi      # 0x86c0
callq 0x4235
jmp 0x3333
popq %rbx
retq
movq $0x0, 0x53ab(%rip) # 0x86c0
movl $0x0, 0x53a9(%rip)      # 0x86c8
xorps %xmm0, %xmm0
movups %xmm0, 0x7ddf(%rip)     # 0xb108
movl $0x544d47, 0x95d5(%rip) # imm = 0x544D47
popq %rbx
jmp 0x4268
// File: /workspace/github_c_makefile_star2_O1/lyda[P]tz/localtime.c
// Function: settzname
static void
settzname(void)
{
	register struct state * const	sp = lclptr;
	register int			i;

	tzname[0] = wildabbr;
	tzname[1] = wildabbr;
#ifdef USG_COMPAT
	daylight = 0;
	timezone = 0;
#endif /* defined USG_COMPAT */
#ifdef ALTZONE
	altzone = 0;
#endif /* defined ALTZONE */
#ifdef ALL_STATE
	if (sp == NULL) {
		tzname[0] = tzname[1] = gmt;
		return;
	}
#endif /* defined ALL_STATE */
	/*
	** And to get the latest zone names into tzname. . .
	*/
	for (i = 0; i < sp->timecnt; ++i) {
		register const struct ttinfo * const	ttisp =
							&sp->ttis[
								sp->types[i]];

		tzname[ttisp->tt_isdst] =
			&sp->chars[ttisp->tt_abbrind];
#ifdef USG_COMPAT
		if (ttisp->tt_isdst)
			daylight = 1;
		if (!ttisp->tt_isdst)
			timezone = -(ttisp->tt_gmtoff);
#endif /* defined USG_COMPAT */
#ifdef ALTZONE
		if (ttisp->tt_isdst)
			altzone = -(ttisp->tt_gmtoff);
#endif /* defined ALTZONE */
	}
	/*
	** Finally, scrub the abbreviations.
	** First, replace bogus characters.
	*/
	for (i = 0; i < sp->charcnt; ++i)
		if (strchr(TZ_ABBR_CHAR_SET, sp->chars[i]) == NULL)
			sp->chars[i] = TZ_ABBR_ERR_CHAR;
	/*
	** Second, truncate long abbreviations.
	*/
	for (i = 0; i < sp->typecnt; ++i) {
		register const struct ttinfo * const	ttisp = &sp->ttis[i];
		register char *				cp = &sp->chars[ttisp->tt_abbrind];

		if (strlen(cp) > TZ_ABBR_MAX_LEN &&
			strcmp(cp, GRANDPARENTED) != 0)
				*(cp + TZ_ABBR_MAX_LEN) = '\0';
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x3ed8(%rip), %rax      # 0x8150
movq %rax, 0x3ee1(%rip)      # 0x8160
movq %rax, 0x3ee2(%rip)      # 0x8168
movslq 0x4437(%rip), %rax      # 0x86c4
leaq 0x442c(%rip), %r15      # 0x86c0
testq %rax, %rax
jle 0x42d5
xorl %ecx, %ecx
leaq 0x3ebe(%rip), %rdx      # 0x8160
movzbl 0x2598(%rcx,%r15), %esi
leaq (%rsi,%rsi,2), %rsi
movslq 0x2a54(%r15,%rsi,8), %rdi
addq %r15, %rdi
addq $0x4248, %rdi           # imm = 0x4248
movslq 0x2a50(%r15,%rsi,8), %rsi
movq %rdi, (%rdx,%rsi,8)
incq %rcx
cmpq %rcx, %rax
jne 0x42a2
movslq 0x43f0(%rip), %r14      # 0x86cc
testq %r14, %r14
jle 0x4317
xorl %r12d, %r12d
leaq 0x1f7d(%rip), %rbx      # 0x6268
movsbl 0x4248(%r12,%r15), %esi
movl $0x45, %edx
movq %rbx, %rdi
callq 0x2120
testq %rax, %rax
jne 0x430f
movb $0x5f, 0x4248(%r12,%r15)
incq %r12
cmpq %r12, %r14
jne 0x42eb
cmpl $0x0, 0x43aa(%rip)      # 0x86c8
jle 0x4375
leaq 0x6ded(%rip), %r12      # 0xb114
xorl %r13d, %r13d
leaq 0x1f7c(%rip), %rbx      # 0x62ad
movslq (%r12), %rax
leaq (%rax,%r15), %r14
addq $0x4248, %r14           # imm = 0x4248
movq %r14, %rdi
callq 0x20c0
cmpq $0x11, %rax
jb 0x4362
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2150
testl %eax, %eax
je 0x4362
movb $0x0, 0x10(%r14)
incq %r13
movslq 0x435c(%rip), %rax      # 0x86c8
addq $0x18, %r12
cmpq %rax, %r13
jl 0x4331
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lyda[P]tz/localtime.c
// Function: typesequiv
static int
typesequiv(sp, a, b)
const struct state * const	sp;
const int			a;
const int			b;
{
	register int	result;

	if (sp == NULL ||
		a < 0 || a >= sp->typecnt ||
		b < 0 || b >= sp->typecnt)
			result = FALSE;
	else {
		register const struct ttinfo *	ap = &sp->ttis[a];
		register const struct ttinfo *	bp = &sp->ttis[b];
		result = ap->tt_gmtoff == bp->tt_gmtoff &&
			ap->tt_isdst == bp->tt_isdst &&
			ap->tt_ttisstd == bp->tt_ttisstd &&
			ap->tt_ttisgmt == bp->tt_ttisgmt &&
			strcmp(&sp->chars[ap->tt_abbrind],
			&sp->chars[bp->tt_abbrind]) == 0;
	}
	return result;
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x4875
movl 0x8(%rdi), %ecx
cmpl %esi, %ecx
setle %r8b
cmpl %edx, %ecx
setle %cl
orb %r8b, %cl
jne 0x4875
movl %esi, %ecx
leaq (%rcx,%rcx,2), %rcx
movl %edx, %edx
leaq (%rdx,%rdx,2), %rsi
movq 0x2a48(%rdi,%rcx,8), %rdx
cmpq 0x2a48(%rdi,%rsi,8), %rdx
jne 0x4875
leaq (%rdi,%rcx,8), %rdx
addq $0x2a48, %rdx           # imm = 0x2A48
leaq (%rdi,%rsi,8), %rcx
addq $0x2a48, %rcx           # imm = 0x2A48
movl 0x8(%rdx), %esi
cmpl 0x8(%rcx), %esi
jne 0x4875
movl 0x10(%rdx), %esi
cmpl 0x10(%rcx), %esi
jne 0x4875
movl 0x14(%rdx), %esi
cmpl 0x14(%rcx), %esi
jne 0x4875
pushq %rax
movslq 0xc(%rdx), %rax
addq %rdi, %rax
addq $0x4248, %rax           # imm = 0x4248
movslq 0xc(%rcx), %rcx
leaq (%rdi,%rcx), %rsi
addq $0x4248, %rsi           # imm = 0x4248
movq %rax, %rdi
callq 0x2150
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/dpw[P]skinny-mutex/test.c
// Function: main
int main(void)
{
	test_static_mutex();

	do_test(test_lock_unlock, 1);
	do_test(test_contention, 1);
	do_test(test_lock_cancellation, 1);
	do_test(test_trylock, 0);
	do_test(test_cond_wait, 1);
	do_test(test_cond_timedwait, 1);
	do_test(test_cond_wait_cancellation, 1);
	do_test(test_unlock_not_held, 0);

	return 0;
}

// Assembly:
pushq %rax
movl $0x1, %ecx
xorl %eax, %eax
lock
cmpxchgq %rcx, 0x4317(%rip)      # 0x60f8
jne 0x1e91
xorl %ecx, %ecx
movl $0x1, %eax
lock
cmpxchgq %rcx, 0x4301(%rip)      # 0x60f8
jne 0x1e9b
cmpq $0x0, 0x42f3(%rip)      # 0x60f8
jne 0x1ea5
leaq 0x44e(%rip), %rdi       # 0x2260
movl $0x1, %esi
callq 0x1ec4
leaq 0x473(%rip), %rdi       # 0x2296
movl $0x1, %esi
callq 0x1ec4
leaq 0x5ce(%rip), %rdi       # 0x2402
movl $0x1, %esi
callq 0x1ec4
leaq 0x6bb(%rip), %rdi       # 0x2500
xorl %esi, %esi
callq 0x1ec4
leaq 0x84e(%rip), %rdi       # 0x26a1
movl $0x1, %esi
callq 0x1ec4
leaq 0x99a(%rip), %rdi       # 0x27fe
movl $0x1, %esi
callq 0x1ec4
leaq 0xab4(%rip), %rdi       # 0x2929
movl $0x1, %esi
callq 0x1ec4
leaq 0xbe0(%rip), %rdi       # 0x2a66
xorl %esi, %esi
callq 0x1ec4
xorl %eax, %eax
popq %rcx
retq
callq 0x11d0
jmp 0x1de7
callq 0x1200
jmp 0x1dfd
leaq 0x12f2(%rip), %rdi      # 0x319e
leaq 0x12a3(%rip), %rsi      # 0x3156
leaq 0x12a3(%rip), %rcx      # 0x315d
movl $0xe, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/dpw[P]skinny-mutex/test.c
// Function: test_contention
static void test_contention(skinny_mutex_t *mutex)
{
	struct test_contention tc;
	pthread_t threads[10];
	int i;

	tc.mutex = mutex;
	tc.held = 0;
	tc.count = 0;

	assert(!skinny_mutex_lock(tc.mutex));

	for (i = 0; i < 10; i++)
		assert(!pthread_create(&threads[i], NULL, bump, &tc));

	assert(!skinny_mutex_unlock(tc.mutex));

	for (i = 0; i < 10; i++)
		assert(!pthread_join(threads[i], NULL));

	assert(!skinny_mutex_lock(tc.mutex));
	assert(!tc.held);
	assert(tc.count == 10);
	assert(!skinny_mutex_unlock(tc.mutex));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, (%rsp)
movq $0x0, 0x8(%rsp)
movl $0x1, %ecx
xorl %eax, %eax
lock
cmpxchgq %rcx, (%rdi)
jne 0x2367
xorl %r15d, %r15d
leaq 0x94f(%rip), %rbx       # 0x2c17
movq %rsp, %r14
leaq (%rsp,%r15), %rdi
addq $0x10, %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1130
testl %eax, %eax
jne 0x2386
addq $0x8, %r15
cmpq $0x50, %r15
jne 0x22cb
movq (%rsp), %rdi
xorl %ecx, %ecx
movl $0x1, %eax
lock
cmpxchgq %rcx, (%rdi)
jne 0x2371
xorl %ebx, %ebx
movq 0x10(%rsp,%rbx,8), %rdi
xorl %esi, %esi
callq 0x1170
testl %eax, %eax
jne 0x23a5
incq %rbx
cmpq $0xa, %rbx
jne 0x2306
movq (%rsp), %rdi
movl $0x1, %ecx
xorl %eax, %eax
lock
cmpxchgq %rcx, (%rdi)
jne 0x2378
cmpl $0x0, 0x8(%rsp)
jne 0x23c4
cmpl $0xa, 0xc(%rsp)
jne 0x23e3
movq (%rsp), %rdi
xorl %ecx, %ecx
movl $0x1, %eax
lock
cmpxchgq %rcx, (%rdi)
jne 0x237f
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x132e
jmp 0x22be
callq 0x1357
jmp 0x2304
callq 0x1380
jmp 0x2335
callq 0x13a9
jmp 0x235d
leaq 0x1292(%rip), %rdi      # 0x361f
leaq 0xdc2(%rip), %rsi       # 0x3156
leaq 0x125d(%rip), %rcx      # 0x35f8
movl $0x42, %edx
callq 0x10b0
leaq 0x12c0(%rip), %rdi      # 0x366c
leaq 0xda3(%rip), %rsi       # 0x3156
leaq 0x123e(%rip), %rcx      # 0x35f8
movl $0x47, %edx
callq 0x10b0
leaq 0x12c1(%rip), %rdi      # 0x368c
leaq 0xd84(%rip), %rsi       # 0x3156
leaq 0x121f(%rip), %rcx      # 0x35f8
movl $0x4a, %edx
callq 0x10b0
leaq 0x12ab(%rip), %rdi      # 0x3695
leaq 0xd65(%rip), %rsi       # 0x3156
leaq 0x1200(%rip), %rcx      # 0x35f8
movl $0x4b, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/dpw[P]skinny-mutex/test.c
// Function: test_lock_cancellation
static void test_lock_cancellation(skinny_mutex_t *mutex)
{
	pthread_t thread;
	void *retval;

	assert(!skinny_mutex_lock(mutex));
	assert(!pthread_create(&thread, NULL, lock_cancellation_thread,
			       mutex));
	delay();
	assert(!pthread_cancel(thread));
	assert(!skinny_mutex_unlock(mutex));
	assert(!pthread_join(thread, &retval));
	assert(!retval);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x1, %ecx
xorl %eax, %eax
lock
cmpxchgq %rcx, (%rdi)
jne 0x2470
leaq 0x86b(%rip), %rdx       # 0x2c8a
movq %rsp, %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x1130
testl %eax, %eax
jne 0x2484
callq 0x2bd0
movq (%rsp), %rdi
callq 0x1190
testl %eax, %eax
jne 0x24a3
xorl %ecx, %ecx
movl $0x1, %eax
lock
cmpxchgq %rcx, (%rbx)
jne 0x247a
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1170
testl %eax, %eax
jne 0x24c2
cmpq $0x0, 0x8(%rsp)
jne 0x24e1
addq $0x10, %rsp
popq %rbx
retq
movq %rbx, %rdi
callq 0x13d2
jmp 0x2418
movq %rbx, %rdi
callq 0x13fb
jmp 0x2450
leaq 0x12a2(%rip), %rdi      # 0x372d
leaq 0xcc4(%rip), %rsi       # 0x3156
leaq 0x1266(%rip), %rcx      # 0x36ff
movl $0x5f, %edx
callq 0x10b0
leaq 0x12c3(%rip), %rdi      # 0x376d
leaq 0xca5(%rip), %rsi       # 0x3156
leaq 0x1247(%rip), %rcx      # 0x36ff
movl $0x61, %edx
callq 0x10b0
leaq 0x12bc(%rip), %rdi      # 0x3785
leaq 0xc86(%rip), %rsi       # 0x3156
leaq 0x1228(%rip), %rcx      # 0x36ff
movl $0x63, %edx
callq 0x10b0
leaq 0x12bc(%rip), %rdi      # 0x37a4
leaq 0xc67(%rip), %rsi       # 0x3156
leaq 0x1209(%rip), %rcx      # 0x36ff
movl $0x64, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/dpw[P]skinny-mutex/test.c
// Function: test_trylock
static void test_trylock(skinny_mutex_t *mutex)
{
	pthread_t thread1, thread2;

	assert(!skinny_mutex_trylock(mutex));

	assert(!pthread_create(&thread1, NULL, trylock_thread, mutex));
	assert(!pthread_join(thread1, NULL));

	assert(!pthread_create(&thread1, NULL, trylock_contender_thread,
			       mutex));
	delay();
	assert(!pthread_create(&thread2, NULL, trylock_thread, mutex));
	assert(!pthread_join(thread2, NULL));
	assert(!skinny_mutex_unlock(mutex));
	assert(!pthread_join(thread1, NULL));
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x19cd
testl %eax, %eax
jne 0x25c8
leaq 0x7a6(%rip), %rdx       # 0x2cc2
movq %rsp, %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x1130
testl %eax, %eax
jne 0x25e7
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x1170
testl %eax, %eax
jne 0x2606
leaq 0x7a5(%rip), %rdx       # 0x2cf0
movq %rsp, %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x1130
testl %eax, %eax
jne 0x2625
callq 0x2bd0
leaq 0x756(%rip), %rdx       # 0x2cc2
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x1130
testl %eax, %eax
jne 0x2644
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x1170
testl %eax, %eax
jne 0x2663
xorl %ecx, %ecx
movl $0x1, %eax
lock
cmpxchgq %rcx, (%rbx)
jne 0x25be
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x1170
testl %eax, %eax
jne 0x2682
addq $0x10, %rsp
popq %rbx
retq
movq %rbx, %rdi
callq 0x1424
jmp 0x25a5
leaq 0x1204(%rip), %rdi      # 0x37d3
leaq 0xb80(%rip), %rsi       # 0x3156
leaq 0x1213(%rip), %rcx      # 0x37f0
movl $0x7c, %edx
callq 0x10b0
leaq 0x1226(%rip), %rdi      # 0x3814
leaq 0xb61(%rip), %rsi       # 0x3156
leaq 0x11f4(%rip), %rcx      # 0x37f0
movl $0x7e, %edx
callq 0x10b0
leaq 0x123e(%rip), %rdi      # 0x384b
leaq 0xb42(%rip), %rsi       # 0x3156
leaq 0x11d5(%rip), %rcx      # 0x37f0
movl $0x7f, %edx
callq 0x10b0
leaq 0x123c(%rip), %rdi      # 0x3868
leaq 0xb23(%rip), %rsi       # 0x3156
leaq 0x11b6(%rip), %rcx      # 0x37f0
movl $0x82, %edx
callq 0x10b0
leaq 0x125e(%rip), %rdi      # 0x38a9
leaq 0xb04(%rip), %rsi       # 0x3156
leaq 0x1197(%rip), %rcx      # 0x37f0
movl $0x84, %edx
callq 0x10b0
leaq 0x1276(%rip), %rdi      # 0x38e0
leaq 0xae5(%rip), %rsi       # 0x3156
leaq 0x1178(%rip), %rcx      # 0x37f0
movl $0x85, %edx
callq 0x10b0
leaq 0x11c2(%rip), %rdi      # 0x384b
leaq 0xac6(%rip), %rsi       # 0x3156
leaq 0x1159(%rip), %rcx      # 0x37f0
movl $0x87, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/dpw[P]skinny-mutex/test.c
// Function: test_cond_wait
static void test_cond_wait(skinny_mutex_t *mutex)
{
	struct test_cond_wait tcw;
	pthread_t thread;

	tcw.mutex = mutex;
	assert(!pthread_cond_init(&tcw.cond, NULL));
	tcw.flag = 0;

	assert(!pthread_create(&thread, NULL, test_cond_wait_thread, &tcw));

	delay();
	assert(!skinny_mutex_lock(mutex));
	tcw.flag = 1;
	assert(!pthread_cond_signal(&tcw.cond));
	assert(!skinny_mutex_unlock(mutex));

	assert(!pthread_join(thread, NULL));

	assert(!pthread_cond_destroy(&tcw.cond));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0x10(%rsp), %rbx
movq %rdi, -0x8(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10f0
testl %eax, %eax
jne 0x2763
leaq 0x8(%rsp), %rcx
movl $0x0, 0x38(%rcx)
leaq 0x659(%rip), %rdx       # 0x2d32
movq %rsp, %rdi
xorl %esi, %esi
callq 0x1130
testl %eax, %eax
jne 0x2782
callq 0x2bd0
movl $0x1, %ecx
xorl %eax, %eax
lock
cmpxchgq %rcx, (%r14)
jne 0x274f
movl $0x1, 0x40(%rsp)
movq %rbx, %rdi
callq 0x10c0
testl %eax, %eax
jne 0x27a1
xorl %ecx, %ecx
movl $0x1, %eax
lock
cmpxchgq %rcx, (%r14)
jne 0x2759
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x1170
testl %eax, %eax
jne 0x27c0
movq %rbx, %rdi
callq 0x1150
testl %eax, %eax
jne 0x27df
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x144f
jmp 0x26fe
movq %r14, %rdi
callq 0x147a
jmp 0x2724
leaq 0x11fc(%rip), %rdi      # 0x3966
leaq 0x9e5(%rip), %rsi       # 0x3156
leaq 0x1212(%rip), %rcx      # 0x398a
movl $0xaa, %edx
callq 0x10b0
leaq 0x1227(%rip), %rdi      # 0x39b0
leaq 0x9c6(%rip), %rsi       # 0x3156
leaq 0x11f3(%rip), %rcx      # 0x398a
movl $0xad, %edx
callq 0x10b0
leaq 0x1244(%rip), %rdi      # 0x39ec
leaq 0x9a7(%rip), %rsi       # 0x3156
leaq 0x11d4(%rip), %rcx      # 0x398a
movl $0xb2, %edx
callq 0x10b0
leaq 0xb63(%rip), %rdi       # 0x332a
leaq 0x988(%rip), %rsi       # 0x3156
leaq 0x11b5(%rip), %rcx      # 0x398a
movl $0xb5, %edx
callq 0x10b0
leaq 0x1226(%rip), %rdi      # 0x3a0c
leaq 0x969(%rip), %rsi       # 0x3156
leaq 0x1196(%rip), %rcx      # 0x398a
movl $0xb7, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/dpw[P]skinny-mutex/test.c
// Function: test_cond_timedwait
static void test_cond_timedwait(skinny_mutex_t *mutex)
{
	pthread_cond_t cond;
	struct timespec t;

	assert(!pthread_cond_init(&cond, NULL));

	assert(!clock_gettime(CLOCK_REALTIME, &t));

	t.tv_nsec += 1000000;
	if (t.tv_nsec > 1000000000) {
		t.tv_nsec -= 1000000000;
		t.tv_sec++;
	}

	assert(!skinny_mutex_lock(mutex));
	assert(skinny_mutex_cond_timedwait(&cond, mutex, &t) == ETIMEDOUT);
	assert(!skinny_mutex_unlock(mutex));

	assert(!pthread_cond_destroy(&cond));
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x10f0
testl %eax, %eax
jne 0x28ad
movq %rsp, %rsi
xorl %edi, %edi
callq 0x1050
testl %eax, %eax
jne 0x28cc
movq 0x8(%rsp), %rax
leaq 0xf4240(%rax), %rcx
movq %rcx, 0x8(%rsp)
cmpq $0x3b8b87c1, %rax       # imm = 0x3B8B87C1
jl 0x2854
addq $-0x3b8b87c0, %rax      # imm = 0xC4747840
movq %rax, 0x8(%rsp)
incq (%rsp)
movl $0x1, %ecx
xorl %eax, %eax
lock
cmpxchgq %rcx, (%rbx)
jne 0x2899
leaq 0x10(%rsp), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
callq 0x1cd7
cmpl $0x6e, %eax
jne 0x28eb
xorl %ecx, %ecx
movl $0x1, %eax
lock
cmpxchgq %rcx, (%rbx)
jne 0x28a3
leaq 0x10(%rsp), %rdi
callq 0x1150
testl %eax, %eax
jne 0x290a
addq $0x40, %rsp
popq %rbx
retq
movq %rbx, %rdi
callq 0x14a5
jmp 0x2862
movq %rbx, %rdi
callq 0x14d0
jmp 0x2885
leaq 0x1231(%rip), %rdi      # 0x3ae5
leaq 0x89b(%rip), %rsi       # 0x3156
leaq 0x1243(%rip), %rcx      # 0x3b05
movl $0xbf, %edx
callq 0x10b0
leaq 0x125d(%rip), %rdi      # 0x3b30
leaq 0x87c(%rip), %rsi       # 0x3156
leaq 0x1224(%rip), %rcx      # 0x3b05
movl $0xc1, %edx
callq 0x10b0
leaq 0x1261(%rip), %rdi      # 0x3b53
leaq 0x85d(%rip), %rsi       # 0x3156
leaq 0x1205(%rip), %rcx      # 0x3b05
movl $0xca, %edx
callq 0x10b0
leaq 0x127d(%rip), %rdi      # 0x3b8e
leaq 0x83e(%rip), %rsi       # 0x3156
leaq 0x11e6(%rip), %rcx      # 0x3b05
movl $0xcd, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/dpw[P]skinny-mutex/test.c
// Function: test_cond_wait_cancellation
static void test_cond_wait_cancellation(skinny_mutex_t *mutex)
{
	struct test_cond_wait tcw;
	pthread_t thread;
	void *retval;

	tcw.mutex = mutex;
	assert(!pthread_cond_init(&tcw.cond, NULL));
	tcw.flag = 0;

	assert(!pthread_create(&thread, NULL, test_cond_wait_thread, &tcw));

	delay();
	assert(!pthread_cancel(thread));
	assert(!pthread_join(thread, &retval));
	assert(retval == PTHREAD_CANCELED);

	assert(!pthread_cond_destroy(&tcw.cond));
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
leaq 0x18(%rsp), %rbx
movq %rdi, -0x8(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10f0
testl %eax, %eax
jne 0x29ac
leaq 0x10(%rsp), %rcx
movl $0x0, 0x38(%rcx)
leaq 0x3da(%rip), %rdx       # 0x2d32
movq %rsp, %rdi
xorl %esi, %esi
callq 0x1130
testl %eax, %eax
jne 0x29cb
callq 0x2bd0
movq (%rsp), %rdi
callq 0x1190
testl %eax, %eax
jne 0x29ea
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1170
testl %eax, %eax
jne 0x2a09
cmpq $-0x1, 0x8(%rsp)
jne 0x2a28
movq %rbx, %rdi
callq 0x1150
testl %eax, %eax
jne 0x2a47
addq $0x50, %rsp
popq %rbx
retq
leaq 0xfb3(%rip), %rdi       # 0x3966
leaq 0x79c(%rip), %rsi       # 0x3156
leaq 0x11ea(%rip), %rcx      # 0x3bab
movl $0xd7, %edx
callq 0x10b0
leaq 0xfde(%rip), %rdi       # 0x39b0
leaq 0x77d(%rip), %rsi       # 0x3156
leaq 0x11cb(%rip), %rcx      # 0x3bab
movl $0xda, %edx
callq 0x10b0
leaq 0xd7c(%rip), %rdi       # 0x376d
leaq 0x75e(%rip), %rsi       # 0x3156
leaq 0x11ac(%rip), %rcx      # 0x3bab
movl $0xdd, %edx
callq 0x10b0
leaq 0xd75(%rip), %rdi       # 0x3785
leaq 0x73f(%rip), %rsi       # 0x3156
leaq 0x118d(%rip), %rcx      # 0x3bab
movl $0xde, %edx
callq 0x10b0
leaq 0xaba(%rip), %rdi       # 0x34e9
leaq 0x720(%rip), %rsi       # 0x3156
leaq 0x116e(%rip), %rcx      # 0x3bab
movl $0xdf, %edx
callq 0x10b0
leaq 0xfbe(%rip), %rdi       # 0x3a0c
leaq 0x701(%rip), %rsi       # 0x3156
leaq 0x114f(%rip), %rcx      # 0x3bab
movl $0xe1, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/dpw[P]skinny-mutex/test.c
// Function: do_test_cond_thread
static void *do_test_cond_thread(void *v_dt)
{
	struct do_test_cond *dt = v_dt;

	assert(!skinny_mutex_lock(&dt->mutex));
	dt->phase = 1;
	assert(!pthread_cond_signal(&dt->cond));

	do {
		assert(!skinny_mutex_cond_wait(&dt->cond, &dt->mutex));
	} while (dt->phase != 2);

	assert(!skinny_mutex_unlock(&dt->mutex));

	return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %ecx
xorl %eax, %eax
lock
cmpxchgq %rcx, (%rdi)
jne 0x2af9
movl $0x1, 0x38(%rbx)
leaq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x10c0
testl %eax, %eax
jne 0x2b2c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1dc9
testl %eax, %eax
jne 0x2b0d
cmpl $0x2, 0x38(%rbx)
jne 0x2acc
xorl %ecx, %ecx
movl $0x1, %eax
lock
cmpxchgq %rcx, (%rbx)
jne 0x2b03
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x14fb
jmp 0x2ab5
movq %rbx, %rdi
callq 0x1526
jmp 0x2aef
leaq 0x8d4(%rip), %rdi       # 0x33e8
leaq 0x63b(%rip), %rsi       # 0x3156
leaq 0x884(%rip), %rcx       # 0x33a6
movl $0x101, %edx            # imm = 0x101
callq 0x10b0
leaq 0x895(%rip), %rdi       # 0x33c8
leaq 0x61c(%rip), %rsi       # 0x3156
leaq 0x865(%rip), %rcx       # 0x33a6
movl $0xfe, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/dpw[P]skinny-mutex/test.c
// Function: do_test_hammer_thread
static void *do_test_hammer_thread(void *v_m)
{
	skinny_mutex_t *m = v_m;

	for (;;) {
		assert(!skinny_mutex_lock(m));
		assert(!skinny_mutex_unlock(m));
		pthread_testcancel();
	}

	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movl $0x1, %r15d
xorl %eax, %eax
lock
cmpxchgq %r15, (%rbx)
jne 0x2b78
movl $0x1, %eax
lock
cmpxchgq %r14, (%rbx)
jne 0x2b86
callq 0x10e0
jmp 0x2b5c
movq %rbx, %rdi
callq 0x178c
testl %eax, %eax
je 0x2b65
jmp 0x2bb1
movq %rbx, %rdi
callq 0x1b92
testl %eax, %eax
je 0x2b71
leaq 0x9a5(%rip), %rdi       # 0x353e
leaq 0x5b6(%rip), %rsi       # 0x3156
leaq 0x973(%rip), %rcx       # 0x351a
movl $0x12e, %edx            # imm = 0x12E
callq 0x10b0
leaq 0x94c(%rip), %rdi       # 0x3504
leaq 0x597(%rip), %rsi       # 0x3156
leaq 0x954(%rip), %rcx       # 0x351a
movl $0x12d, %edx            # imm = 0x12D
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/dpw[P]skinny-mutex/test.c
// Function: delay
static void delay(void)
{
	struct timespec ts;
	ts.tv_sec = 0;
	ts.tv_nsec = 1000000;
	assert(!nanosleep(&ts, NULL));
}

// Assembly:
subq $0x18, %rsp
leaq 0x8(%rsp), %rdi
movq $0x0, (%rdi)
movq $0xf4240, 0x8(%rdi)     # imm = 0xF4240
xorl %esi, %esi
callq 0x10a0
testl %eax, %eax
jne 0x2bf8
addq $0x18, %rsp
retq
leaq 0x957(%rip), %rdi       # 0x3556
leaq 0x550(%rip), %rsi       # 0x3156
leaq 0x95f(%rip), %rcx       # 0x356c
movl $0x1d, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/dpw[P]skinny-mutex/test.c
// Function: bump
static void *bump(void *v_tc)
{
	struct test_contention *tc = v_tc;

	assert(!skinny_mutex_lock(tc->mutex));
	assert(!tc->held);
	tc->held = 1;
	delay();
	tc->held = 0;
	tc->count++;
	assert(!skinny_mutex_unlock(tc->mutex));

	return NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movl $0x1, %ecx
xorl %eax, %eax
lock
cmpxchgq %rcx, (%rdi)
jne 0x2c5d
cmpl $0x0, 0x8(%rbx)
jne 0x2c6b
movl $0x1, 0x8(%rbx)
callq 0x2bd0
movl $0x0, 0x8(%rbx)
incl 0xc(%rbx)
movq (%rbx), %rdi
xorl %ecx, %ecx
movl $0x1, %eax
lock
cmpxchgq %rcx, (%rdi)
jne 0x2c64
xorl %eax, %eax
popq %rbx
retq
callq 0x1551
jmp 0x2c2c
callq 0x157a
jmp 0x2c59
leaq 0xa63(%rip), %rdi       # 0x36d5
leaq 0x4dd(%rip), %rsi       # 0x3156
leaq 0xa42(%rip), %rcx       # 0x36c2
movl $0x2b, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/dpw[P]skinny-mutex/test.c
// Function: lock_cancellation_thread
static void *lock_cancellation_thread(void *v_mutex)
{
	skinny_mutex_t *mutex = v_mutex;
 	assert(!skinny_mutex_lock(mutex));
	assert(!skinny_mutex_unlock(mutex));
	return NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %ecx
xorl %eax, %eax
lock
cmpxchgq %rcx, (%rdi)
jne 0x2cae
xorl %ecx, %ecx
movl $0x1, %eax
lock
cmpxchgq %rcx, (%rbx)
jne 0x2cb8
xorl %eax, %eax
popq %rbx
retq
movq %rbx, %rdi
callq 0x15a3
jmp 0x2c9c
movq %rbx, %rdi
callq 0x15cc
jmp 0x2caa
// File: /workspace/github_c_makefile_star2_O1/dpw[P]skinny-mutex/test.c
// Function: trylock_contender_thread
static void *trylock_contender_thread(void *v_mutex)
{
	skinny_mutex_t *mutex = v_mutex;
	assert(!skinny_mutex_lock(mutex));
	delay();
	delay();
	assert(!skinny_mutex_unlock(mutex));
	return NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %ecx
xorl %eax, %eax
lock
cmpxchgq %rcx, (%rdi)
jne 0x2d1e
callq 0x2bd0
callq 0x2bd0
xorl %ecx, %ecx
movl $0x1, %eax
lock
cmpxchgq %rcx, (%rbx)
jne 0x2d28
xorl %eax, %eax
popq %rbx
retq
movq %rbx, %rdi
callq 0x15f5
jmp 0x2d02
movq %rbx, %rdi
callq 0x161e
jmp 0x2d1a
// File: /workspace/github_c_makefile_star2_O1/dpw[P]skinny-mutex/test.c
// Function: test_cond_wait_thread
static void *test_cond_wait_thread(void *v_tcw)
{
	struct test_cond_wait *tcw = v_tcw;

	assert(!skinny_mutex_lock(tcw->mutex));
	pthread_cleanup_push(test_cond_wait_cleanup, tcw);

	while (!tcw->flag)
		assert(!skinny_mutex_cond_wait(&tcw->cond, tcw->mutex));

	pthread_cleanup_pop(1);
	return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
xorl %eax, %eax
movl $0x1, %ecx
lock
cmpxchgq %rcx, (%rdi)
jne 0x2db5
movq %rsp, %rdi
xorl %esi, %esi
callq 0x1180
testl %eax, %eax
jne 0x2dbc
movq %rsp, %rdi
callq 0x1160
leaq 0x8(%rbx), %r14
cmpl $0x0, 0x38(%rbx)
jne 0x2d9b
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x1dc9
testl %eax, %eax
je 0x2d67
leaq 0xced(%rip), %rdi       # 0x3a70
leaq 0x3cc(%rip), %rsi       # 0x3156
leaq 0xcbb(%rip), %rcx       # 0x3a4c
movl $0x9e, %edx
callq 0x10b0
movq %rsp, %rdi
callq 0x1090
movq %rbx, %rdi
callq 0x2dcc
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
callq 0x1647
jmp 0x2d4d
movq %rbx, %rdi
callq 0x2dcc
movq %rsp, %rdi
callq 0x1120