LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/syzcch[P]FEC_C_version/./fec_rs.h
// Function: rscode::rscode(int, int, int)
rscode(int allnum, int rsnum, int dataLength)
    {
        allNum = allnum;
        rsNum = rsnum;
        num = allNum - rsNum;
        stripe_unit_size = dataLength;
        gf_already_setup = 0;

        // use allnum here, rs includes original data and redudant data
        rs = (char **) malloc(sizeof(char *)*allNum);
        for(int i=0; i<allNum; i++)
        {
            rs[i]=(char *) malloc(sizeof(char)*stripe_unit_size);
            memset(rs[i],0,stripe_unit_size);
        }
        inthis = new int[allNum];
        for(int i = 0; i < allNum; i++)
        {
            inthis[i] = 0;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x3a03(%rip), %rax      # 0x4d60
movq %rax, (%rdi)
movl %esi, 0x1c(%rdi)
movl %edx, 0x24(%rdi)
movl %esi, %eax
subl %edx, %eax
movl %eax, 0x8(%rdi)
movl %ecx, 0x20(%rdi)
andl $0x0, 0x18(%rdi)
movl %esi, %edi
shlq $0x3, %rdi
callq 0x10f0
movq %rax, 0x10(%rbx)
xorl %r15d, %r15d
movl %r14d, %r14d
cmpq %r14, %r15
jae 0x13bd
movslq 0x20(%rbx), %r14
movq %r14, %rdi
callq 0x10f0
movq 0x10(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x1060
incq %r15
movl 0x1c(%rbx), %r14d
jmp 0x1386
leaq (,%r14,4), %rdi
callq 0x1030
movq %rax, 0x28(%rbx)
xorl %ecx, %ecx
cmpq %rcx, %r14
je 0x13de
andl $0x0, (%rax,%rcx,4)
incq %rcx
jmp 0x13d0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/syzcch[P]FEC_C_version/./fec_rs.h
// Function: rscode::outputOrigin()
void outputOrigin()
    {

        printf("After decoding:");
        for(int i=0; i < num; i++)
        {
            printf("data:%d:  ",i);
            printf(rs[i]);
            printf("\n");
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x17ca(%rip), %rdi      # 0x31f5
xorl %eax, %eax
callq 0x1040
leaq 0x17cc(%rip), %r14      # 0x3205
pushq $0xa
popq %r15
xorl %r12d, %r12d
movl 0x8(%rbx), %eax
cmpq %rax, %r12
jae 0x1a71
movq %r14, %rdi
movl %r12d, %esi
xorl %eax, %eax
callq 0x1040
movq 0x10(%rbx), %rax
movq (%rax,%r12,8), %rdi
xorl %eax, %eax
callq 0x1040
movl %r15d, %edi
callq 0x1100
incq %r12
jmp 0x1a40
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/syzcch[P]FEC_C_version/./fec_rs.h
// Function: rscode::outputData()
void outputData()
    {

        printf("The res:");
        for(int i = num; i < allNum; i++)
        {
            printf(rs[i]);
            printf("\n");
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1782(%rip), %rdi      # 0x3210
xorl %eax, %eax
callq 0x1040
movslq 0x8(%rbx), %r15
pushq $0xa
popq %r14
cmpl %r15d, 0x1c(%rbx)
jbe 0x1abf
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdi
xorl %eax, %eax
callq 0x1040
movl %r14d, %edi
callq 0x1100
incq %r15
jmp 0x1a9d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/syzcch[P]FEC_C_version/./fec_rs.h
// Function: rscode::gf_single_divide(int, int)
int gf_single_divide(int a, int b)
    {
        int sum_j;
        gf_modar_setup();
        if (b == 0)
            return -1;
        if (a == 0)
            return 0;
        sum_j = B_TO_J[a] - B_TO_J[b];

        return (int) J_TO_B[sum_j];
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %r14d
callq 0x209a
testl %ebx, %ebx
je 0x1dfe
testl %r14d, %r14d
je 0x1e03
movslq %r14d, %rax
leaq 0x32fc(%rip), %rcx      # 0x50e0
movslq (%rcx,%rax,4), %rax
movslq %ebx, %rdx
movslq (%rcx,%rdx,4), %rcx
subq %rcx, %rax
movq 0x32df(%rip), %rcx      # 0x50d8
movl (%rcx,%rax,4), %eax
jmp 0x1e05
pushq $-0x1
popq %rax
jmp 0x1e05
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/syzcch[P]FEC_C_version/./fec_rs.h
// Function: rscode::gf_mult_region(void*, int, int)
void gf_mult_region(void *region, int size, int factor)
    {
        int sum_j;
        int flog;
        unsigned char *r;
        int sz;
        int r_cache;

        gf_modar_setup();

        if (factor == 1)
            return;
        if (factor == 0)
        {
            (void) memset(region, 0, size);
            return;
        }

        flog = B_TO_J[factor];
        sz = size / sizeof(unsigned char);
        r = ((unsigned char *) region) + sz;

        while (r != region)
        {
            r--;
            r_cache = *r;
            if (r_cache != 0)
            {
                sum_j = (int) (B_TO_J[r_cache] + flog);

                *r = J_TO_B[sum_j];
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %r14d
movq %rsi, %rbx
callq 0x209a
cmpl $0x1, %r15d
je 0x1e80
testl %r15d, %r15d
jne 0x1e44
movslq %r14d, %rdx
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1060
movslq %r15d, %rcx
leaq 0x3292(%rip), %rax      # 0x50e0
movslq (%rax,%rcx,4), %rcx
movslq %r14d, %rdx
movq 0x327c(%rip), %rsi      # 0x50d8
testq %rdx, %rdx
je 0x1e80
movzbl -0x1(%rbx,%rdx), %edi
testq %rdi, %rdi
je 0x1e7b
movslq (%rax,%rdi,4), %rdi
addq %rcx, %rdi
movb (%rsi,%rdi,4), %dil
movb %dil, -0x1(%rbx,%rdx)
decq %rdx
jmp 0x1e5c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/syzcch[P]FEC_C_version/./fec_rs.h
// Function: rscode::gf_add_parity(void*, void*, int)
void gf_add_parity(void *to_add, void *to_modify, int size)
    {
        unsigned long ta, tm;
        unsigned char *cta, *ctm;
        int sml;

        if (size <= 0)
            return;

        ta = (unsigned long) to_add % sizeof(unsigned long);
        tm = (unsigned long) to_modify% sizeof(unsigned long);
        if (ta != tm)
        {
            printf("Error: gf_add_parity: to_add and to_modify are not aligned\n");
        }

        cta = (unsigned char *) to_add;
        ctm = (unsigned char *) to_modify;

        /* Align to long boundary */
        if (ta != 0)
        {
            while (ta != sizeof(unsigned long) && size > 0)
            {
                *ctm = *ctm ^ *cta;
                ctm++;
                cta++;
                size--;
                ta++;
            }
        }

        if (size == 0)
            return;

        /* Call gf_fast_add_parity to do it fast */

        sml = size / sizeof(unsigned long);

        if (sml > 0)
        {
            gf_fast_add_parity(cta, ctm, size);
        }
        size -= sml * sizeof(unsigned long);

        if (size == 0)
        {
            return;
        }

        /* Do the last few bytes if they are unalighed */
        cta += sml * sizeof(unsigned long);
        ctm += sml * sizeof(unsigned long);

        while (size > 0)
        {
            *ctm = *ctm ^ *cta;
            ctm++;
            cta++;
            size--;
        }
    }

// Assembly:
testl %ecx, %ecx
jle 0x1f48
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movl %r14d, %r13d
andl $0x7, %r13d
movl %ebx, %eax
andl $0x7, %eax
cmpq %rax, %r13
je 0x1ecb
leaq 0x13f3(%rip), %rdi      # 0x32b9
callq 0x1120
testq %r13, %r13
je 0x1f02
pushq $0x8
popq %rdx
subq %r13, %rdx
movl %r15d, %eax
xorl %ecx, %ecx
cmpq %rcx, %rdx
je 0x1ef1
cmpl %ecx, %eax
je 0x1ef1
movb (%r14,%rcx), %sil
xorb %sil, (%rbx,%rcx)
incq %rcx
jmp 0x1edb
cmpl %ecx, %r15d
je 0x1f3a
addq %rcx, %r14
addq %rcx, %rbx
subq %rcx, %rax
movl %eax, %r15d
cmpl $0x8, %r15d
jb 0x1f19
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %r15d, %ecx
callq 0x21a0
movl %r15d, %eax
andl $0x7, %eax
je 0x1f3a
andl $-0x8, %r15d
movl %r15d, %ecx
testl %eax, %eax
jle 0x1f3a
movb (%r14,%rcx), %dl
xorb %dl, (%rbx,%rcx)
decl %eax
incq %rcx
jmp 0x1f28
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/syzcch[P]FEC_C_version/./fec_rs.h
// Function: rscode::gf_make_vandermonde(int, int)
int *gf_make_vandermonde(int rows, int cols)
    {
        int *vdm, i, j, k;
        void gf_modar_setup();

        if (rows >= 255 || cols >= 255)
        {
            printf("Error: gf_make_vandermonde: %d + %d >= %d\n");
        }

        vdm = (int *) malloc(sizeof(int) * rows * cols);
        if (vdm == NULL)
        {
            printf("Malloc: Vandermonde matrix");
        }
        for (i = 0; i < rows; i++)
        {
            k = 1;
            for (j = 0; j < cols; j++)
            {
                vdm[i*cols+j] = k;
                k = gf_single_multiply(k, i);
            }
        }
        return vdm;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movl %esi, %r12d
movq %rdi, %r15
movl $0xff, %eax
cmpl %eax, %esi
setl %cl
cmpl %eax, %edx
setl %al
testb %al, %cl
jne 0x1f84
leaq 0x1108(%rip), %rdi      # 0x3085
xorl %eax, %eax
callq 0x1040
movslq %r12d, %rdi
movslq %ebx, %r14
imulq %r14, %rdi
shlq $0x2, %rdi
callq 0x10f0
testq %rax, %rax
movq %rax, -0x30(%rbp)
jne 0x1fb2
leaq 0x1109(%rip), %rdi      # 0x30b0
xorl %eax, %eax
callq 0x1040
movq -0x30(%rbp), %rax
xorl %r13d, %r13d
testl %ebx, %ebx
cmovlel %r13d, %ebx
testl %r12d, %r12d
cmovlel %r13d, %r12d
shlq $0x2, %r14
movq %r14, -0x38(%rbp)
movq %rax, %r14
movq %r12, -0x40(%rbp)
cmpq %r12, %r13
je 0x2008
xorl %r12d, %r12d
pushq $0x1
popq %rax
cmpq %r12, %rbx
je 0x1ff7
movl %eax, (%r14,%r12,4)
movq %r15, %rdi
movl %eax, %esi
movl %r13d, %edx
callq 0x2054
incq %r12
jmp 0x1fdc
incq %r13
addq -0x38(%rbp), %r14
movq -0x40(%rbp), %r12
movq -0x30(%rbp), %rax
jmp 0x1fd1
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/syzcch[P]FEC_C_version/./fec_rs.h
// Function: rscode::gf_single_multiply(int, int)
int gf_single_multiply(int xxx, int yyy)
    {
        unsigned int sum_j;
        unsigned char zzz;

        gf_modar_setup();
        if (xxx == 0 || yyy == 0)
        {
            zzz = 0;
        }
        else
        {
            sum_j = (int) (B_TO_J[xxx] + (int) B_TO_J[yyy]);
            zzz = J_TO_B[sum_j];
        }
        return zzz;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %r14d
callq 0x209a
testl %r14d, %r14d
sete %cl
testl %ebx, %ebx
sete %dl
xorl %eax, %eax
orb %cl, %dl
jne 0x2094
movslq %r14d, %rax
leaq 0x3060(%rip), %rcx      # 0x50e0
movslq %ebx, %rdx
movl (%rcx,%rdx,4), %edx
addl (%rcx,%rax,4), %edx
movq 0x3048(%rip), %rax      # 0x50d8
movzbl (%rax,%rdx,4), %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/syzcch[P]FEC_C_version/./fec_rs.h
// Function: rscode::gf_modar_setup()
void gf_modar_setup()
    {
        int j, b, t;
        if (gf_already_setup) return;
        B_TO_J = (int *) malloc(sizeof(int)*256);

        if (B_TO_J == NULL)
        {
            printf("gf_modar_setup, malloc B_TO_J");
        }
        /* When the word size is 8 bits, make three copies of the table so that
          you don't have to do the extra addition or subtraction in the
          multiplication/division routines */

        J_TO_B = (int *) malloc(sizeof(int)*256*3);
        if (J_TO_B == NULL)
        {
            printf("gf_modar_setup, malloc J_TO_B");
        }
        for (j = 0; j < 256; j++)
        {
            B_TO_J[j] = 255;
            J_TO_B[j] = 0;
        }

        b = 1;
        for (j = 0; j < 255; j++)
        {
            if (B_TO_J[b] != 255)
            {
                printf( "Error: j=%d, b=%d, B->J[b]=%d, J->B[j]=%d (0%o)\n");
            }
            B_TO_J[b] = j;
            J_TO_B[j] = b;
            b = b << 1;
            if (b & 256)
            {
                b = (b ^ prim_poly_8) & 255;
            }
        }

        for (j = 0; j < 255; j++)
        {
            J_TO_B[j+255] = J_TO_B[j];
            J_TO_B[j+2*255] = J_TO_B[j];
        }
        J_TO_B += 255;


        gf_already_setup = 1;

    }

// Assembly:
cmpl $0x0, 0x18(%rdi)
je 0x20a1
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xc00, %edi            # imm = 0xC00
callq 0x10f0
movq %rax, 0x3015(%rip)      # 0x50d8
testq %rax, %rax
jne 0x20dd
leaq 0xffc(%rip), %rdi       # 0x30cb
xorl %eax, %eax
callq 0x1040
movq 0x2ffb(%rip), %rax      # 0x50d8
xorl %ecx, %ecx
leaq 0x2ffa(%rip), %r15      # 0x50e0
cmpq $0x400, %rcx            # imm = 0x400
je 0x2101
movl $0xff, (%rcx,%r15)
andl $0x0, (%rax,%rcx)
addq $0x4, %rcx
jmp 0x20e6
pushq $0x1
popq %rcx
leaq 0xfde(%rip), %r14       # 0x30e9
xorl %r12d, %r12d
cmpq $0xff, %r12
je 0x2156
movslq %ecx, %r13
cmpl $0xff, (%r15,%r13,4)
je 0x2135
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
movq 0x2fa3(%rip), %rax      # 0x50d8
movl %r12d, (%r15,%r13,4)
movl %r13d, (%rax,%r12,4)
leal (,%r13,2), %edx
movzbl %dl, %ecx
xorl $0x1d, %ecx
testb %r13b, %r13b
cmovnsl %edx, %ecx
incq %r12
jmp 0x210e
movq $-0x3fc, %rcx           # imm = 0xFC04
testq %rcx, %rcx
je 0x217d
movl 0x3fc(%rax,%rcx), %edx
movl %edx, 0x7f8(%rax,%rcx)
movl %edx, 0xbf4(%rax,%rcx)
addq $0x4, %rcx
jmp 0x215d
addq $0x3fc, %rax            # imm = 0x3FC
movq %rax, 0x2f4e(%rip)      # 0x50d8
movl $0x1, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH17_SpecializedLibraryFacilities/examples/seed.cc
// Function: main
int main()
{
	default_random_engine e1;             // uses the default seed
	default_random_engine e2(2147483646); // use the given seed value

	// e3 and e4 will generate the same sequence 
	// because they use the same seed
	default_random_engine e3;        // uses the default seed value
	e3.seed(32767);                  // call seed to set a new seed value
	default_random_engine e4(32767); // set the seed value to 32767
	for (size_t i = 0; i != 100; ++i) {
		if (e1() == e2())
			cout << "unseeded match at iteration: " << i << endl;
		if (e3() != e4())
			cout << "seeded differs at iteration: " << i << endl;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x7fff, %r13d          # imm = 0x7FFF
movl $0x7ffffffe, %r15d      # imm = 0x7FFFFFFE
pushq $0x1
popq %r12
xorl %ebx, %ebx
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl $0x7fff, %r14d          # imm = 0x7FFF
cmpq $0x64, %rbx
je 0x1295
imulq $0x41a7, %r12, %rax     # imm = 0x41A7
xorl %edx, %edx
divq %rcx
imulq $0x41a7, %r15, %rax     # imm = 0x41A7
movq %rdx, %r12
xorl %edx, %edx
divq %rcx
movq %rdx, %r15
cmpq %rdx, %r12
jne 0x123f
movq 0x2dbd(%rip), %rdi      # 0x3fd8
leaq 0xde2(%rip), %rsi       # 0x2004
callq 0x1060
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1040
movq %rax, %rdi
callq 0x1030
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
imulq $0x41a7, %r13, %rax     # imm = 0x41A7
xorl %edx, %edx
divq %rcx
imulq $0x41a7, %r14, %rax     # imm = 0x41A7
movq %rdx, %r13
xorl %edx, %edx
divq %rcx
movq %rdx, %r14
cmpq %rdx, %r13
je 0x128d
movq 0x2d6f(%rip), %rdi      # 0x3fd8
leaq 0xdb2(%rip), %rsi       # 0x2022
callq 0x1060
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1040
movq %rax, %rdi
callq 0x1030
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
incq %rbx
jmp 0x11e7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/kdungs[P]codecon/src/mug.cc
// Function: main
int main() {
  auto colors =
      std::vector<std::string>{"White", "Black", "Blue", "Red", "Yellow"};

  auto line = std::string{};
  std::cin >> line;  // ignore number

  while (std::cin >> line) {
    auto pos = std::find(std::begin(colors), std::end(colors), line);
    if (pos != std::end(colors)) {
      colors.erase(pos);
      if (colors.size() == 1u) {
        std::cout << colors[0] << '\n';
        break;
      }
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
leaq 0xd25(%rip), %rsi       # 0x2004
leaq 0x20(%rsp), %rbx
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x14b2
leaq 0x40(%rsp), %r15
leaq 0xd0d(%rip), %rsi       # 0x200a
leaq 0x6(%rsp), %rdx
movq %r15, %rdi
callq 0x14b2
leaq 0x60(%rsp), %r15
leaq 0xcfa(%rip), %rsi       # 0x2010
leaq 0x5(%rsp), %rdx
movq %r15, %rdi
callq 0x14b2
leaq 0x80(%rsp), %r15
leaq 0xce3(%rip), %rsi       # 0x2015
leaq 0x4(%rsp), %rdx
movq %r15, %rdi
callq 0x14b2
leaq 0xa0(%rsp), %r15
leaq 0xccb(%rip), %rsi       # 0x2019
leaq 0x3(%rsp), %rdx
movq %r15, %rdi
callq 0x14b2
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
pushq $0x5
popq %rdx
leaq 0x2(%rsp), %rcx
callq 0x14ee
movl $0x80, %ebx
leaq (%rsp,%rbx), %rdi
addq $0x20, %rdi
callq 0x1080
addq $-0x20, %rbx
cmpq $-0x20, %rbx
jne 0x1377
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x2c3a(%rip), %rdi      # 0x3fe0
leaq 0x20(%rsp), %rsi
callq 0x1130
movq 0x2c29(%rip), %rbx      # 0x3fe0
leaq 0x20(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1130
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x1428
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x1767
cmpq 0x10(%rsp), %rax
je 0x13c1
movq %r15, %rdi
movq %rax, %rsi
callq 0x1528
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
subq %rsi, %rax
cmpq $0x20, %rax
jne 0x13c1
movq 0x2bb8(%rip), %rdi      # 0x3fd0
callq 0x10e0
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x1110
leaq 0x20(%rsp), %rdi
callq 0x1080
leaq 0x8(%rsp), %rdi
callq 0x152e
xorl %eax, %eax
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1493
jmp 0x1493
movq %rax, %r14
movl $0x80, %ebx
leaq (%rsp,%rbx), %rdi
addq $0x20, %rdi
callq 0x1080
addq $-0x20, %rbx
cmpq $-0x20, %rbx
jne 0x1457
jmp 0x14aa
jmp 0x1476
jmp 0x1476
jmp 0x1476
movq %rax, %r14
addq $-0x20, %r15
movq %r15, %rdi
callq 0x1080
cmpq %rbx, %r15
jne 0x1479
jmp 0x14aa
movq %rax, %r14
jmp 0x14aa
jmp 0x1493
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x1080
leaq 0x8(%rsp), %rdi
callq 0x152e
movq %r14, %rdi
callq 0x1180
// File: /workspace/github_cpp_makefile_star2_O2/sbingner[P]kerneldec/kerneldec.cpp
// Function: read_asn1len(unsigned char)
uint64_t read_asn1len(uint8_t len)
{
    uint8_t buf[8];
    uint64_t full_len = 0;
    if ((len & 0x80) != 0x80) 
        return len;

    int size = len&0x7F;
    if (size > 8) {
        fprintf(stderr, "Sorry, no support for kernel this large or not a kernel\n");
        exit(1);
    }
    size_t nr = fread(buf, 1, size, _input);
    if (nr != size) {
        perror("read");
        exit(1);
    }
    for (int i=0; i<size; i++) {
        full_len = full_len<<8 | buf[i];
    }
    return le64toh(full_len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testb %dil, %dil
js 0x32f2
movzbl %dil, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
andb $0x7f, %dil
cmpb $0x9, %dil
jae 0x3335
movzbl %dil, %ebx
movq 0x9ee1(%rip), %rcx      # 0xd1e8
leaq -0x10(%rbp), %rdi
pushq $0x1
popq %rsi
movq %rbx, %rdx
callq 0x3130
cmpq %rbx, %rax
jne 0x3353
xorl %ecx, %ecx
xorl %eax, %eax
cmpq %rcx, %rbx
je 0x32eb
shlq $0x8, %rax
movzbl -0x10(%rbp,%rcx), %edx
orq %rdx, %rax
incq %rcx
jmp 0x331f
movq 0x9c9c(%rip), %rax      # 0xcfd8
movq (%rax), %rcx
leaq 0x4cbe(%rip), %rdi      # 0x8004
pushq $0x38
popq %rsi
pushq $0x1
popq %rdx
callq 0x31a0
jmp 0x335f
leaq 0x4ceb(%rip), %rdi      # 0x8045
callq 0x3090
pushq $0x1
popq %rdi
callq 0x30e0
// File: /workspace/github_cpp_makefile_star2_O2/sbingner[P]kerneldec/kerneldec.cpp
// Function: read_asn1str()
char *read_asn1str() {
    uint8_t buf[2];
    read_asn1hdr(buf);
    if (*buf != 0x16) {
        fprintf(stderr, "Invalid input - not string (0x%02x)\n", *buf);
        exit(1);
    }

    uint64_t len = read_asn1len(buf[1]);

    char *str = (char*)calloc(len+1, 1);
    if (fread(str, 1, len, _input) != len) {
        perror("read");
        exit(1);
    }
    if (g_debug) fprintf(stderr, "read str \"%s\"\n", str);
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq -0x1a(%rbp), %rbx
movq %rbx, %rdi
callq 0x3367
movzbl (%rbx), %edx
cmpl $0x16, %edx
jne 0x3427
movzbl -0x19(%rbp), %edi
callq 0x32dc
movq %rax, %r14
leaq 0x1(%rax), %rdi
pushq $0x1
popq %r15
movq %r15, %rsi
callq 0x3070
movq %rax, %rbx
movq 0x9e0b(%rip), %rcx      # 0xd1e8
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3130
cmpq %r14, %rax
jne 0x3441
leaq 0x9e01(%rip), %rax      # 0xd1f8
cmpl $0x0, (%rax)
jne 0x340a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x9bc7(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
leaq 0x4c54(%rip), %rsi      # 0x806f
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3120
jmp 0x33fc
movq 0x9baa(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
leaq 0x4c12(%rip), %rsi      # 0x804a
xorl %eax, %eax
callq 0x3120
jmp 0x344d
leaq 0x4bfd(%rip), %rdi      # 0x8045
callq 0x3090
pushq $0x1
popq %rdi
callq 0x30e0
// File: /workspace/github_cpp_makefile_star2_O2/sbingner[P]kerneldec/lzssdec.cpp
// Function: lzssdecompress::lzssdecompress()
lzssdecompress::lzssdecompress()
{
    _maxmatch= 18;  // 4 bit size + threshold 
    _dictsize= 4096; // 12 bit size
    _copythreshold= 3; // 0 == copy 3 bytes
    _dict= new uint8_t[_dictsize+_maxmatch-1];

    reset();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0x1200001000, %rax     # imm = 0x1200001000
movq %rax, 0x40(%rdi)
movl $0x3, 0x48(%rdi)
movl $0x1011, %edi           # imm = 0x1011
callq 0x3030
movq %rax, 0x38(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3ae6
// File: /workspace/github_cpp_makefile_star2_O2/sbingner[P]kerneldec/lzssdec.cpp
// Function: lzssdecompress::reset()
void lzssdecompress::reset()
{
    _state=EXPECTINGFLAG;
    _flags= 0; _bitnr= 0;
    _src=_srcend=_dst=_dstend=0;
    memset(_dict, ' ', _dictsize+_maxmatch-1);
    _dictptr= _dictsize-_maxmatch;
    _inputoffset= 0;
    _outputoffset= 0;
    _firstbyte= 0;
    _copyptr= 0;
    _copycount= 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, (%rdi)
xorl %r14d, %r14d
movb %r14b, 0x4(%rdi)
andl $0x0, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movq 0x38(%rdi), %rdi
movl 0x40(%rbx), %eax
movl 0x44(%rbx), %ecx
leal -0x1(%rax,%rcx), %eax
movslq %eax, %rdx
pushq $0x20
popq %rsi
callq 0x3050
movl 0x40(%rbx), %eax
subl 0x44(%rbx), %eax
movl %eax, 0x4c(%rbx)
movb %r14b, 0x30(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sbingner[P]kerneldec/lzssdec.cpp
// Function: lzssdecompress::dumpcopydata()
void lzssdecompress::dumpcopydata()
{
    // note: we are printing incorrect data, if _copyptr == _dictptr-1
    for (int i=0 ; i<_copycount ; i++)
        fprintf(stderr, " %02x", _dict[(_copyptr+i)&(_dictsize-1)]);
    fprintf(stderr, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x917b(%rip), %r15      # 0xcfd8
leaq 0x452f(%rip), %r14      # 0x8393
xorl %r12d, %r12d
movq (%r15), %rsi
cmpl 0x54(%rbx), %r12d
jge 0x3e9d
movq 0x38(%rbx), %rax
movl 0x50(%rbx), %ecx
addl %r12d, %ecx
movslq 0x40(%rbx), %rdx
decq %rdx
movslq %ecx, %rcx
andq %rdx, %rcx
movzbl (%rax,%rcx), %edx
movq %rsi, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3120
incl %r12d
jmp 0x3e67
pushq $0xa
popq %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x30f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/sbingner[P]kerneldec/lzssdec.cpp
// Function: lzssdecompress::copyfromdict()
void lzssdecompress::copyfromdict()
{
    while (_dst<_dstend && _copycount)
    {
        addtodict(*_dst++ = _dict[_copyptr++]);
        _outputoffset++;
        _copycount--;
        _copyptr= _copyptr&(_dictsize-1);
    }
    if (_copycount==0)
        nextflagbit();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x54(%rdi), %eax
movq 0x20(%rbx), %rcx
cmpq 0x28(%rbx), %rcx
jae 0x3f02
testl %eax, %eax
je 0x3f02
movq 0x38(%rbx), %rax
movslq 0x50(%rbx), %rdx
leal 0x1(%rdx), %esi
movl %esi, 0x50(%rbx)
movzbl (%rax,%rdx), %esi
leaq 0x1(%rcx), %rax
movq %rax, 0x20(%rbx)
movb %sil, (%rcx)
movq %rbx, %rdi
callq 0x3dec
incl 0x5c(%rbx)
movl 0x40(%rbx), %ecx
movl 0x54(%rbx), %eax
decl %eax
movl %eax, 0x54(%rbx)
decl %ecx
andl %ecx, 0x50(%rbx)
jmp 0x3eba
testl %eax, %eax
je 0x3f0d
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3e0c
nop
// File: /workspace/github_cpp_makefile_star2_O2/sbingner[P]kerneldec/lzssdec.cpp
// Function: lzssdecompress::flush(unsigned char*, unsigned int, unsigned int*)
void lzssdecompress::flush(uint8_t *dst, uint32_t dstlen, uint32_t *pdstused)
{
    if (g_debug) fprintf(stderr, "flash before state= %d, copy: 0x%x, 0x%x\n", _state, _copyptr, _copycount);
    _src= _srcend= NULL;
    _dst= dst;  _dstend= dst+dstlen;

    if (_state==COPYFROMDICT)
        copyfromdict();

    if (pdstused) *pdstused= _dst-dst;
    if (g_debug) fprintf(stderr, "flash after state= %d, copy: 0x%x, 0x%x\n", _state, _copyptr, _copycount);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
cmpl $0x0, 0x92be(%rip)      # 0xd1f8
jne 0x3f7e
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq %r15, 0x20(%rbx)
movl %r12d, %eax
addq %r15, %rax
movq %rax, 0x28(%rbx)
cmpl $0x0, (%rbx)
jne 0x3f5e
movq %rbx, %rdi
callq 0x3eae
testq %r14, %r14
je 0x3f6c
movl 0x20(%rbx), %eax
subl %r15d, %eax
movl %eax, (%r14)
cmpl $0x0, 0x9285(%rip)      # 0xd1f8
jne 0x3fa1
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x9053(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
movl (%rbx), %edx
movl 0x50(%rbx), %ecx
movl 0x54(%rbx), %r8d
leaq 0x43a8(%rip), %rsi      # 0x8340
xorl %eax, %eax
callq 0x3120
jmp 0x3f3c
movq 0x9030(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
movl (%rbx), %edx
movl 0x50(%rbx), %ecx
movl 0x54(%rbx), %r8d
leaq 0x43af(%rip), %rsi      # 0x836a
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3120
nop
// File: /workspace/github_cpp_makefile_star2_O2/ricbit[P]dlx/cover_nospacer.cc
// Function: ExactCover::solve(int)
void solve(int level) {
    if (header[0].rlink == 0) {
      count++;
      return;
    }
    int item = best_item();
    cover(item);
    solution[level].option = nodes[item].dlink;
    for (auto& option = solution[level].option; option != item; option = nodes[option].dlink) {
      try_option(option, solution[level]);
      solve(level + 1);
      rewind_option(option, solution[level]);
    }
    uncover(item);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %rax
movq %rdi, %rbx
cmpl $0x0, 0x4(%rax)
je 0x36f4
movq %rbx, %rdi
movl %esi, %r14d
callq 0x3704
movl %eax, %ebp
movq %rbx, %rdi
movl %eax, %esi
callq 0x373e
movq 0x18(%rbx), %rcx
movslq %ebp, %rax
movq 0x38(%rbx), %r12
movslq %r14d, %r14
imulq $0xc, %rax, %rax
imulq $0xc, %r14, %r15
incl %r14d
leaq 0x8(%rcx,%rax), %rax
addq %r15, %r12
movl (%rax), %esi
movl %esi, (%r12)
cmpl %ebp, %esi
je 0x36e2
movq 0x38(%rbx), %rdx
movq %rbx, %rdi
addq %r15, %rdx
callq 0x378e
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3648
movq 0x38(%rbx), %rdx
movl (%r12), %esi
movq %rbx, %rdi
addq %r15, %rdx
callq 0x379c
movslq (%r12), %rax
movq 0x18(%rbx), %rcx
imulq $0xc, %rax, %rax
leaq 0x8(%rcx,%rax), %rax
jmp 0x3698
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x37a4
incq 0x90(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/bkthomps-hashmap/test.c
// Function: test_int
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	unordered_map h;
	h = unordered_map_init(sizeof(uint32_t), sizeof(uint32_t), hash_int, compare_int);
	for (i = 0, x = x0; i < n; ++i) {
		uint32_t key, v;
		x = hash32(x);
		key = get_key(n, x);
		if (!unordered_map_get(&v, h, &key)) {
			v = 1;
			unordered_map_put(h, &key, &v);
		} else {
			++v;
			unordered_map_put(h, &key, &v);
		}
		z += v;
	}
	fprintf(stderr, "# unique keys: %d; checksum: %u\n", unordered_map_size(h), z);
	x = unordered_map_size(h);
	unordered_map_destroy(h);
	return x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r15d
movl %edi, %r14d
leaq 0xc4(%rip), %rdx        # 0x155a
leaq 0xc0(%rip), %rcx        # 0x155d
pushq $0x4
popq %rdi
movq %rdi, %rsi
callq 0x1564
movq %rax, %rbx
xorl %ebp, %ebp
movl %r14d, 0x10(%rsp)
subl $0x1, %r14d
jb 0x1510
movl %r15d, %edi
callq 0x120c
movl %eax, %r15d
movl 0x10(%rsp), %edi
movl %eax, %esi
callq 0x1237
movl %eax, 0x14(%rsp)
leaq 0xc(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
leaq 0x14(%rsp), %r12
movq %r12, %rdx
callq 0x18ba
movl 0xc(%rsp), %ecx
incl %ecx
testb %al, %al
pushq $0x1
popq %rax
cmovel %eax, %ecx
movl %ecx, 0xc(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x16a0
addl 0xc(%rsp), %ebp
jmp 0x14b2
movq 0x2ae1(%rip), %rax      # 0x3ff8
movq (%rax), %r14
movq %rbx, %rdi
callq 0x1694
leaq 0xb4c(%rip), %rsi       # 0x2075
movq %r14, %rdi
movl %eax, %edx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x1694
movl %eax, %ebp
movq %rbx, %rdi
callq 0x1ad1
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/bkthomps-hashmap/unordered_map.c
// Function: unordered_map_init
unordered_map unordered_map_init(const size_t key_size,
                                 const size_t value_size,
                                 unsigned long (*hash)(const void *const),
                                 int (*comparator)(const void *const,
                                                   const void *const))
{
    struct _unordered_map *const init = malloc(sizeof(struct _unordered_map));
    if (!init) {
        return NULL;
    }
    init->key_size = key_size;
    init->value_size = value_size;
    init->hash = hash;
    init->comparator = comparator;
    init->size = 0;
    init->capacity = STARTING_BUCKETS;
    init->buckets = calloc(STARTING_BUCKETS, sizeof(struct node *));
    if (!init->buckets) {
        free(init);
        return NULL;
    }
    return init;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
pushq $0x30
popq %rdi
callq 0x1080
testq %rax, %rax
je 0x15c2
movq %rax, %rbx
movq %r13, (%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movabsq $0x800000000, %rax      # imm = 0x800000000
movq %rax, 0x20(%rbx)
pushq $0x8
popq %rdi
movq %rdi, %rsi
callq 0x1050
movq %rax, 0x28(%rbx)
testq %rax, %rax
jne 0x15c4
movq %rbx, %rdi
callq 0x1030
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/bkthomps-hashmap/unordered_map.c
// Function: unordered_map_rehash
int unordered_map_rehash(unordered_map me)
{
    struct node **old_buckets = me->buckets;
    me->buckets = calloc((size_t) me->capacity, sizeof(struct node *));
    if (!me->buckets) {
        me->buckets = old_buckets;
        return -ENOMEM;
    }
    for (int i = 0; i < me->capacity; i++) {
        struct node *traverse = old_buckets[i];
        while (traverse) {
            struct node *const backup = traverse->next;
            traverse->hash = me->hash(traverse->key);
            unordered_map_add_item(me, traverse);
            traverse = backup;
        }
    }
    free(old_buckets);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x28(%rdi), %rbx
movl 0x24(%rdi), %ebp
movslq %ebp, %rdi
pushq $0x8
popq %rsi
callq 0x1050
movq %rax, 0x28(%r14)
testq %rax, %rax
je 0x1642
xorl %r12d, %r12d
movslq %ebp, %rax
cmpq %rax, %r12
jge 0x1636
movq (%rbx,%r12,8), %r15
testq %r15, %r15
je 0x162d
movq (%r15), %rdi
movq 0x18(%r15), %r13
callq *0x10(%r14)
movq %rax, 0x10(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x1658
movq %r13, %r15
jmp 0x1609
incq %r12
movl 0x24(%r14), %ebp
jmp 0x15fd
movq %rbx, %rdi
callq 0x1030
xorl %eax, %eax
jmp 0x1649
movq %rbx, 0x28(%r14)
pushq $-0xc
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/bkthomps-hashmap/unordered_map.c
// Function: unordered_map_add_item
static void unordered_map_add_item(unordered_map me, struct node *const add)
{
    const int index = (int) (add->hash % me->capacity);
    add->next = NULL;
    if (!me->buckets[index]) {
        me->buckets[index] = add;
        return;
    }
    struct node *traverse = me->buckets[index];
    while (traverse->next) {
        traverse = traverse->next;
    }
    traverse->next = add;
}

// Assembly:
movq 0x10(%rsi), %rax
movslq 0x24(%rdi), %rcx
xorl %edx, %edx
divq %rcx
andq $0x0, 0x18(%rsi)
movq 0x28(%rdi), %rax
movslq %edx, %rdx
movq (%rax,%rdx,8), %rcx
testq %rcx, %rcx
je 0x168c
movq %rcx, %rax
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0x167a
addq $0x18, %rax
jmp 0x1690
leaq (%rax,%rdx,8), %rax
movq %rsi, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/bkthomps-hashmap/unordered_map.c
// Function: unordered_map_put
int unordered_map_put(unordered_map me, void *const key, void *const value)
{

    const unsigned long hash = me->hash(key);
    const int index = (int) (hash % me->capacity);
    if (!me->buckets[index]) {
        me->buckets[index] = unordered_map_create_element(me, hash, key, value);
        if (!me->buckets[index]) {
            return -ENOMEM;
        }
    } else {
        struct node *traverse = me->buckets[index];
        if (unordered_map_is_equal(me, traverse, hash, key)) {
            memcpy(traverse->value, value, me->value_size);
            return 0;
        }
        while (traverse->next) {
            traverse = traverse->next;
            if (unordered_map_is_equal(me, traverse, hash, key)) {
                memcpy(traverse->value, value, me->value_size);
                return 0;
            }
        }
        traverse->next = unordered_map_create_element(me, hash, key, value);
        if (!traverse->next) {
            return -ENOMEM;
        }
    }
    me->size++;
    if (me->size >= RESIZE_AT * me->capacity) {
        return unordered_map_resize(me);
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq *0x10(%rbx)
movq %rax, %r12
movslq 0x24(%rbx), %rcx
xorl %edx, %edx
divq %rcx
movq 0x28(%rbx), %rax
movslq %edx, %r13
movq (%rax,%r13,8), %rbp
testq %rbp, %rbp
je 0x171a
cmpq %r12, 0x10(%rbp)
jne 0x16ee
movq (%rbp), %rdi
movq %r15, %rsi
callq *0x18(%rbx)
testl %eax, %eax
je 0x17e9
movq 0x18(%rbp), %r13
testq %r13, %r13
je 0x1743
movq %r13, %rbp
cmpq %r12, 0x10(%r13)
jne 0x16ee
movq (%r13), %rdi
movq %r15, %rsi
callq *0x18(%rbx)
movq %r13, %rbp
testl %eax, %eax
jne 0x16ee
movq 0x8(%r13), %rdi
jmp 0x17ed
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1813
movq 0x28(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
movq 0x28(%rbx), %rax
cmpq $0x0, (%rax,%r13,8)
jne 0x1761
jmp 0x1801
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1813
movq %rax, 0x18(%rbp)
testq %rax, %rax
je 0x1801
movl 0x20(%rbx), %eax
movl 0x24(%rbx), %r15d
incl %eax
cvtsi2sd %eax, %xmm1
movl %eax, 0x20(%rbx)
cvtsi2sd %r15d, %xmm0
movsd 0x91a(%rip), %xmm2      # 0x2098
mulsd %xmm0, %xmm2
xorl %eax, %eax
ucomisd %xmm2, %xmm1
jb 0x1804
mulsd 0x90e(%rip), %xmm0      # 0x20a0
cvttsd2si %xmm0, %ebp
movq 0x28(%rbx), %r14
movslq %ebp, %rdi
pushq $0x8
popq %rsi
callq 0x1050
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0x17fd
movl %ebp, 0x24(%rbx)
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
cmpq %r15, %r12
je 0x17df
movq (%r14,%r12,8), %rsi
testq %rsi, %rsi
je 0x17da
movq 0x18(%rsi), %r13
movq %rbx, %rdi
callq 0x1658
movq %r13, %rsi
jmp 0x17c4
incq %r12
jmp 0x17bb
movq %r14, %rdi
callq 0x1030
jmp 0x17f9
movq 0x8(%rbp), %rdi
movq 0x8(%rbx), %rdx
movq %r14, %rsi
callq 0x1070
xorl %eax, %eax
jmp 0x1804
movq %r14, 0x28(%rbx)
pushq $-0xc
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/bkthomps-hashmap/unordered_map.c
// Function: unordered_map_create_element
static struct node *const unordered_map_create_element(unordered_map me,
                                                       const unsigned long hash,
                                                       const void *const key,
                                                       const void *const value)
{
    struct node *const init = malloc(sizeof(struct node));
    if (!init) {
        return NULL;
    }
    init->key = malloc(me->key_size);
    if (!init->key) {
        free(init);
        return NULL;
    }
    memcpy(init->key, key, me->key_size);
    init->value = malloc(me->value_size);
    if (!init->value) {
        free(init->key);
        free(init);
        return NULL;
    }
    memcpy(init->value, value, me->value_size);
    init->hash = hash;
    init->next = NULL;
    return init;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r12
pushq $0x20
popq %rdi
callq 0x1080
testq %rax, %rax
je 0x18a6
movq %rax, %rbx
movq %r14, (%rsp)
movq (%r12), %r14
movq %r14, %rdi
callq 0x1080
movq %rax, (%rbx)
testq %rax, %rax
je 0x189e
movq %rax, %rbp
movq %rax, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x1070
movq 0x8(%r12), %r14
movq %r14, %rdi
callq 0x1080
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x1896
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1070
movq (%rsp), %rax
movq %rax, 0x10(%rbx)
andq $0x0, 0x18(%rbx)
jmp 0x18a8
movq %rbp, %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1030
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/bkthomps-hashmap/unordered_map.c
// Function: unordered_map_get
bool unordered_map_get(void *const value, unordered_map me, void *const key)
{
    const unsigned long hash = me->hash(key);
    const int index = (int) (hash % me->capacity);
    struct node *traverse = me->buckets[index];
    while (traverse) {
        if (unordered_map_is_equal(me, traverse, hash, key)) {
            memcpy(value, traverse->value, me->value_size);
            return true;
        }
        traverse = traverse->next;
    }
    return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rdi
callq *0x10(%rsi)
movq %rax, %r12
movslq 0x24(%r14), %rcx
xorl %edx, %edx
divq %rcx
movslq %edx, %r13
shlq $0x3, %r13
addq 0x28(%r14), %r13
movq (%r13), %r13
testq %r13, %r13
je 0x191d
cmpq %r12, 0x10(%r13)
jne 0x1907
movq (%r13), %rdi
movq %r15, %rsi
callq *0x18(%r14)
testl %eax, %eax
je 0x190d
addq $0x18, %r13
jmp 0x18e9
movq 0x8(%r13), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x1070
testq %r13, %r13
setne %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/bkthomps-hashmap/unordered_map.c
// Function: unordered_map_contains
bool unordered_map_contains(unordered_map me, void *const key)
{
    const unsigned long hash = me->hash(key);
    const int index = (int) (hash % me->capacity);
    const struct node *traverse = me->buckets[index];
    while (traverse) {
        if (unordered_map_is_equal(me, traverse, hash, key)) {
            return true;
        }
        traverse = traverse->next;
    }
    return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq *0x10(%r14)
movq %rax, %r15
movslq 0x24(%r14), %rcx
xorl %edx, %edx
divq %rcx
movslq %edx, %r12
shlq $0x3, %r12
addq 0x28(%r14), %r12
movq (%r12), %r12
testq %r12, %r12
je 0x197e
cmpq %r15, 0x10(%r12)
jne 0x1978
movq (%r12), %rdi
movq %rbx, %rsi
callq *0x18(%r14)
testl %eax, %eax
je 0x197e
addq $0x18, %r12
jmp 0x1959
testq %r12, %r12
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/bkthomps-hashmap/unordered_map.c
// Function: unordered_map_remove
bool unordered_map_remove(unordered_map me, void *const key)
{
    const unsigned long hash = me->hash(key);
    const int index = (int) (hash % me->capacity);
    if (!me->buckets[index]) {
        return false;
    }
    struct node *traverse = me->buckets[index];
    if (unordered_map_is_equal(me, traverse, hash, key)) {
        me->buckets[index] = traverse->next;
        free(traverse->key);
        free(traverse->value);
        free(traverse);
        me->size--;
        return true;
    }
    while (traverse->next) {
        if (unordered_map_is_equal(me, traverse->next, hash, key)) {
            struct node *const backup = traverse->next;
            traverse->next = traverse->next->next;
            free(backup->key);
            free(backup->value);
            free(backup);
            me->size--;
            return true;
        }
        traverse = traverse->next;
    }
    return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq *0x10(%rbx)
movq %rax, %r12
movslq 0x24(%rbx), %rsi
xorl %ecx, %ecx
xorl %edx, %edx
divq %rsi
movq 0x28(%rbx), %rax
movslq %edx, %r13
movq (%rax,%r13,8), %r14
testq %r14, %r14
je 0x1a31
cmpq %r12, 0x10(%r14)
jne 0x19d6
movq (%r14), %rdi
movq %r15, %rsi
callq *0x18(%rbx)
testl %eax, %eax
je 0x1a07
movq %r14, %r13
movq 0x18(%r14), %r14
testq %r14, %r14
je 0x1a03
cmpq %r12, 0x10(%r14)
jne 0x19d6
movq (%r14), %rdi
movq %r15, %rsi
callq *0x18(%rbx)
movq 0x18(%r13), %r14
testl %eax, %eax
jne 0x19d6
movq 0x18(%r14), %rax
movq %rax, 0x18(%r13)
jmp 0x1a13
xorl %ecx, %ecx
jmp 0x1a31
movq 0x18(%r14), %rax
movq 0x28(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
movq (%r14), %rdi
callq 0x1030
movq 0x8(%r14), %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
decl 0x20(%rbx)
movb $0x1, %cl
movl %ecx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/bkthomps-hashmap/unordered_map.c
// Function: unordered_map_clear
int unordered_map_clear(unordered_map me)
{
    struct node **temp =
            calloc((size_t) STARTING_BUCKETS, sizeof(struct node *));
    if (!temp) {
        return -ENOMEM;
    }
    for (int i = 0; i < me->capacity; i++) {
        struct node *traverse = me->buckets[i];
        while (traverse) {
            struct node *const backup = traverse;
            traverse = traverse->next;
            free(backup->key);
            free(backup->value);
            free(backup);
        }
        me->buckets[i] = NULL;
    }
    me->size = 0;
    me->capacity = STARTING_BUCKETS;
    free(me->buckets);
    me->buckets = temp;
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x8
popq %rdi
movq %rdi, %rsi
callq 0x1050
testq %rax, %rax
je 0x1ac4
movq %rax, %r14
xorl %r12d, %r12d
movslq 0x24(%rbx), %rax
cmpq %rax, %r12
jge 0x1aa5
movq 0x28(%rbx), %rax
movq (%rax,%r12,8), %r15
testq %r15, %r15
je 0x1a97
movq (%r15), %rdi
movq 0x18(%r15), %r13
callq 0x1030
movq 0x8(%r15), %rdi
callq 0x1030
movq %r15, %rdi
callq 0x1030
movq %r13, %r15
jmp 0x1a70
movq 0x28(%rbx), %rax
andq $0x0, (%rax,%r12,8)
incq %r12
jmp 0x1a5f
movabsq $0x800000000, %rax      # imm = 0x800000000
movq %rax, 0x20(%rbx)
movq 0x28(%rbx), %rdi
callq 0x1030
movq %r14, 0x28(%rbx)
xorl %eax, %eax
jmp 0x1ac7
pushq $-0xc
popq %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/bkthomps-hashmap/unordered_map.c
// Function: unordered_map_destroy
unordered_map unordered_map_destroy(unordered_map me)
{
    unordered_map_clear(me);
    free(me->buckets);
    free(me);
    return NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1a3d
movq 0x28(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1030
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH03_StringsVectorsAndArrays/examples/hexify.cc
// Function: main
int main()
{
	const string hexdigits = "0123456789ABCDEF";  // possible hex digits

	cout << "Enter a series of numbers between 0 and 15"
	     << " separated by spaces.  Hit ENTER when finished: " 
	     << endl;
	string result;        // will hold the resulting hexify'd string

	string::size_type n;  // hold numbers from the input
	while (cin >> n)
		if (n < hexdigits.size())    // ignore invalid input
			result += hexdigits[n];  // fetch the indicated hex digit

	cout << "Your hex number is: " << result << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
leaq 0xde4(%rip), %rsi       # 0x2004
leaq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x1030
movq 0x2d9c(%rip), %rdi      # 0x3fd0
leaq 0xdda(%rip), %rsi       # 0x2015
callq 0x10a0
leaq 0xdf9(%rip), %rsi       # 0x2040
movq %rax, %rdi
callq 0x10a0
movq %rax, %rdi
callq 0x1050
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x2d72(%rip), %rbx      # 0x3fe0
leaq -0x20(%rbp), %r14
leaq -0x40(%rbp), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1060
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x12ab
movq -0x20(%rbp), %rax
cmpq -0x58(%rbp), %rax
jae 0x1276
movq -0x60(%rbp), %rcx
movsbl (%rcx,%rax), %esi
movq %r15, %rdi
callq 0x1070
jmp 0x1276
movq 0x2d1e(%rip), %rdi      # 0x3fd0
leaq 0xdb8(%rip), %rsi       # 0x2071
callq 0x10a0
leaq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1050
leaq -0x40(%rbp), %rdi
callq 0x1040
leaq -0x60(%rbp), %rdi
callq 0x1040
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x12f8
movq %rax, %rbx
jmp 0x1304
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x1040
leaq -0x60(%rbp), %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x10c0
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/src/threads/part2/SafeGuard.cpp
// Function: main
int main(){
    Counter counter;

    std::vector<std::thread> threads;

    for(int i = 0; i < 5; ++i){
        threads.push_back(std::thread([&](){
            for(int i = 0; i < 100; ++i){
                counter.increment();
            }
        }));
    }

    for(auto& thread : threads){
        thread.join();
    }

    std::cout << counter.value << std::endl;

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq 0xc(%rsp), %rax
leaq 0x20(%rsp), %rbx
vxorps %xmm0, %xmm0, %xmm0
andl $0x0, (%rax)
andq $0x0, 0x10(%rbx)
vmovaps %xmm0, (%rbx)
pushq $0x5
popq %rbp
pushq $0x10
popq %r14
leaq 0x2b06(%rip), %r13      # 0x3d88
leaq 0x18(%rsp), %r15
leaq 0x10(%rsp), %r12
subl $0x1, %ebp
jb 0x12e2
andq $0x0, 0x18(%rsp)
movq %r14, %rdi
callq 0x10d0
leaq 0xc(%rsp), %rcx
movq %r13, (%rax)
movq %rax, 0x10(%rsp)
movq %rcx, 0x8(%rax)
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x10b0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x12cd
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x13f8
movq %r15, %rdi
callq 0x138a
jmp 0x128c
movq 0x20(%rsp), %rbx
movq 0x28(%rsp), %r14
cmpq %r14, %rbx
je 0x12ff
movq %rbx, %rdi
callq 0x10f0
addq $0x8, %rbx
jmp 0x12ec
movl 0xc(%rsp), %esi
movq 0x2cce(%rip), %rdi      # 0x3fd8
callq 0x1100
movq %rax, %rdi
callq 0x1070
leaq 0x20(%rsp), %rdi
callq 0x1398
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1336
jmp 0x1336
movq %rax, %rbx
jmp 0x135d
movq 0x10(%rsp), %rdi
movq %rax, %rbx
testq %rdi, %rdi
je 0x135d
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x135d
leaq 0x18(%rsp), %rdi
movq %rax, %rbx
callq 0x138a
leaq 0x20(%rsp), %rdi
callq 0x1398
movq %rbx, %rdi
callq 0x1110
nop