LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/png/pngwutil.c
// Function: png_write_sCAL
void /* PRIVATE */
png_write_sCAL(png_structp png_ptr, int unit, double width, double height)
{
   PNG_sCAL;
   char buf[64];
   png_size_t total_len;

   png_debug(1, "in png_write_sCAL");

   buf[0] = (char)unit;
   png_snprintf(buf + 1, 63, "%12.12e", width);
   total_len = 1 + png_strlen(buf + 1) + 1;
   png_snprintf(buf + total_len, 64-total_len, "%12.12e", height);
   total_len += png_strlen(buf + total_len);

   png_debug1(3, "sCAL total length = %u", (unsigned int)total_len);
   png_write_chunk(png_ptr, (png_bytep)png_sCAL, (png_bytep)buf, total_len);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movsd %xmm1, (%rsp)
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movb $0x0, 0x4(%r14)
movl $0x4c414373, (%r14)     # imm = 0x4C414373
leaq 0x11(%rsp), %r15
movb %sil, -0x1(%r15)
leaq 0x141b1(%rip), %r12     # 0xb41a2
movl $0x3f, %esi
movq %r15, %rdi
movq %r12, %rdx
movb $0x1, %al
callq 0xe750
movq %r15, %rdi
callq 0xe1e0
movq %rax, %r15
leaq (%rsp,%rax), %r13
addq $0x12, %r13
movl $0x3e, %esi
subq %rax, %rsi
movq %r13, %rdi
movq %r12, %rdx
movsd (%rsp), %xmm0
movb $0x1, %al
callq 0xe750
movq %r13, %rdi
callq 0xe1e0
leaq (%rax,%r15), %rcx
addq $0x2, %rcx
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9e2b1
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/png/pngwutil.c
// Function: png_write_pHYs
void /* PRIVATE */
png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit,
   png_uint_32 y_pixels_per_unit,
   int unit_type)
{
   PNG_pHYs;
   png_byte buf[9];

   png_debug(1, "in png_write_pHYs");

   if (unit_type >= PNG_RESOLUTION_LAST)
      png_warning(png_ptr, "Unrecognized unit type for pHYs chunk");

   png_save_uint_32(buf, x_pixels_per_unit);
   png_save_uint_32(buf + 4, y_pixels_per_unit);
   buf[8] = (png_byte)unit_type;

   png_write_chunk(png_ptr, (png_bytep)png_pHYs, buf, (png_size_t)9);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movl %edx, %ecx
movl %esi, %ebx
movq %rdi, %r14
movb $0x0, 0xc(%rsp)
movl $0x73594870, 0x8(%rsp)  # imm = 0x73594870
cmpl $0x2, %ebp
jl 0xa0098
leaq 0x14120(%rip), %rsi     # 0xb41aa
movq %r14, %rdi
movl %ecx, %r15d
callq 0x92e6e
movl %r15d, %ecx
movl %ebx, %eax
shrl $0x18, %eax
leaq 0xf(%rsp), %rdx
movb %al, (%rdx)
movl %ebx, %eax
shrl $0x10, %eax
movb %al, 0x1(%rdx)
movb %bh, 0x11(%rsp)
movb %bl, 0x3(%rdx)
movl %ecx, %eax
shrl $0x18, %eax
movb %al, 0x4(%rdx)
movl %ecx, %eax
shrl $0x10, %eax
movb %al, 0x5(%rdx)
movb %ch, 0x15(%rsp)
movb %cl, 0x7(%rdx)
movb %bpl, 0x8(%rdx)
leaq 0x8(%rsp), %rsi
movl $0x9, %ecx
movq %r14, %rdi
callq 0x9e2b1
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/png/pngwutil.c
// Function: png_write_tIME
void /* PRIVATE */
png_write_tIME(png_structp png_ptr, png_timep mod_time)
{
   PNG_tIME;
   png_byte buf[7];

   png_debug(1, "in png_write_tIME");

   if (mod_time->month  > 12 || mod_time->month  < 1 ||
       mod_time->day    > 31 || mod_time->day    < 1 ||
       mod_time->hour   > 23 || mod_time->second > 60)
   {
      png_warning(png_ptr, "Invalid time specified for tIME chunk");
      return;
   }

   png_save_uint_16(buf, mod_time->year);
   buf[2] = mod_time->month;
   buf[3] = mod_time->day;
   buf[4] = mod_time->hour;
   buf[5] = mod_time->minute;
   buf[6] = mod_time->second;

   png_write_chunk(png_ptr, (png_bytep)png_tIME, buf, (png_size_t)7);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movb $0x0, 0x8(%rsp)
movl $0x454d4974, 0x4(%rsp)  # imm = 0x454D4974
movb 0x2(%rsi), %al
leal -0xd(%rax), %ecx
cmpb $-0xc, %cl
jb 0xa0127
movb 0x3(%rsi), %cl
leal -0x20(%rcx), %edx
cmpb $-0x1f, %dl
jb 0xa0127
movb 0x4(%rsi), %r8b
cmpb $0x17, %r8b
ja 0xa0127
movb 0x6(%rsi), %r9b
cmpb $0x3d, %r9b
jb 0xa0138
leaq 0x140a2(%rip), %rsi     # 0xb41d0
addq $0x10, %rsp
popq %rbx
jmp 0x92e6e
movzwl (%rsi), %ebx
movb %bh, 0x9(%rsp)
leaq 0x9(%rsp), %rdx
movb %bl, 0x1(%rdx)
movb %al, 0x2(%rdx)
movb %cl, 0x3(%rdx)
movb %r8b, 0x4(%rdx)
movb 0x5(%rsi), %al
movb %al, 0x5(%rdx)
movb %r9b, 0x6(%rdx)
leaq 0x4(%rsp), %rsi
movl $0x7, %ecx
callq 0x9e2b1
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/png/pngwio.c
// Function: png_default_write_data
void PNGAPI
png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
{
   png_uint_32 check;

   if (png_ptr == NULL)
      return;
   check = fwrite(data, 1, length, (png_FILE_p)(png_ptr->io_ptr));
   if (check != length)
      png_error(png_ptr, "Write Error");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa14bf
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %rbx
movq 0xf8(%rdi), %rcx
movl $0x1, %esi
movq %rax, %rdi
callq 0xe8b0
movl %eax, %eax
cmpq %r14, %rax
jne 0xa14c7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x12d60(%rip), %rsi     # 0xb422e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x92dd0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/png/adler32.c
// Function: adler32_combine_
local uLong adler32_combine_(adler1, adler2, len2)
    uLong adler1;
    uLong adler2;
    z_off64_t len2;
{
    unsigned long sum1;
    unsigned long sum2;
    unsigned rem;

    /* the derivation of this formula is left as an exercise for the reader */
    rem = (unsigned)(len2 % BASE);
    sum1 = adler1 & 0xffff;
    sum2 = rem * sum1;
    MOD(sum2);
    sum1 += (adler2 & 0xffff) + BASE - 1;
    sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
    if (sum1 >= BASE) sum1 -= BASE;
    if (sum1 >= BASE) sum1 -= BASE;
    if (sum2 >= (BASE << 1)) sum2 -= (BASE << 1);
    if (sum2 >= BASE) sum2 -= BASE;
    return sum1 | (sum2 << 16);
}

// Assembly:
movq %rdx, %rcx
movabsq $0xf00e10d2fc5cd, %rdx  # imm = 0xF00E10D2FC5CD
movq %rcx, %rax
mulq %rdx
movq %rcx, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0xf, %rax
imulq $0xfff1, %rax, %rax     # imm = 0xFFF1
subq %rax, %rcx
movl $0xffff, %r9d           # imm = 0xFFFF
movq %rdi, %r10
andq %r9, %r10
movq %rcx, %r8
imulq %r10, %r8
movabsq $0x1000f00e10d30, %rdx  # imm = 0x1000F00E10D30
movq %r8, %rax
mulq %rdx
andq %rsi, %r9
shrl $0x10, %edi
shrl $0x10, %esi
addq %rdi, %rsi
subq %rcx, %rsi
imulq $0xfff1, %rdx, %rax     # imm = 0xFFF1
subq %rax, %r8
leaq (%r10,%r9), %rax
addl $0xfff0, %eax           # imm = 0xFFF0
addq %r8, %rsi
movl $0xfff1, %ecx           # imm = 0xFFF1
leaq (%rsi,%rcx), %rdx
cmpl $0xfff1, %eax           # imm = 0xFFF1
leaq -0x1(%r10,%r9), %rax
movl $0xfff0, %edi           # imm = 0xFFF0
cmovaeq %rax, %rdi
movq $-0xfff1, %rax          # imm = 0xFFFF000F
leaq (%rdi,%rax), %r8
cmpq %rcx, %rdi
cmovbq %rdi, %r8
addq %rax, %rsi
cmpq $0x1ffe2, %rdx          # imm = 0x1FFE2
cmovbq %rdx, %rsi
movq %rsi, %rdx
shlq $0x10, %rdx
movabsq $-0xfff10000, %rax      # imm = 0xFFFFFFFF000F0000
addq %rdx, %rax
cmpq %rcx, %rsi
cmovbq %rdx, %rax
orq %r8, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/EverybodyHops[P]Permutations/media_number.cpp
// Function: media_number::print_num()
void media_number::print_num(){
    cout << "now num: ";
    for(int i = num.size() - 1; i >= 0; i--){
        cout << num[i] << " ";
    }
    cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x6caa(%rip), %rbx      # 0x8fd8
leaq 0x3ccf(%rip), %rsi      # 0x6004
movl $0x9, %edx
movq %rbx, %rdi
callq 0x20f0
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x2, %rax
decl %eax
js 0x238a
movl %eax, %r13d
incq %r13
movq 0x6c7a(%rip), %r15      # 0x8fd8
leaq 0x3ca7(%rip), %r12      # 0x600c
movq (%r14), %rax
movl -0x4(%rax,%r13,4), %esi
movq %r15, %rdi
callq 0x2130
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x20f0
decq %r13
jg 0x2365
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2080
nop
// File: /workspace/github_cpp_makefile_star2_O1/EverybodyHops[P]Permutations/media_number.cpp
// Function: media_number::print_carry()
void media_number::print_carry(){
    cout << "now carry: ";
    for(int i = carry.size() - 1; i >= 0; i--){
        cout << carry[i] << " ";
    }
    cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x6c00(%rip), %rbx      # 0x8fd8
leaq 0x3c2f(%rip), %rsi      # 0x600e
movl $0xb, %edx
movq %rbx, %rdi
callq 0x20f0
movq 0x20(%r14), %rax
subq 0x18(%r14), %rax
shrq $0x2, %rax
decl %eax
js 0x2436
movl %eax, %r13d
incq %r13
movq 0x6bcf(%rip), %r15      # 0x8fd8
leaq 0x3bfc(%rip), %r12      # 0x600c
movq 0x18(%r14), %rax
movl -0x4(%rax,%r13,4), %esi
movq %r15, %rdi
callq 0x2130
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x20f0
decq %r13
jg 0x2410
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2080
nop
// File: /workspace/github_cpp_makefile_star2_O1/EverybodyHops[P]Permutations/media_number.cpp
// Function: media_number::dec2media(int)
vector<int> media_number::dec2media(int dec){
    vector<int> res;
    int t = 0;
    while(dec > 0){
        if(t == carry.size()){
            res.push_back(dec);
            break;
        }
        res.push_back(dec % carry[t]);
        dec /= carry[t++];
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %edx, -0x24(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
testl %edx, %edx
jle 0x2548
movl %edx, %eax
movq %rsi, %r14
xorl %r12d, %r12d
leaq -0x28(%rbp), %r15
movq 0x18(%r14), %rcx
movq 0x20(%r14), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rdx, %r12
je 0x2526
cltd
idivl (%rcx,%r12,4)
movl %edx, -0x28(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2503
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x250e
movq %rbx, %rdi
movq %r15, %rdx
callq 0x2e12
movq 0x18(%r14), %rcx
movl -0x24(%rbp), %eax
cltd
idivl (%rcx,%r12,4)
incq %r12
movl %eax, -0x24(%rbp)
testl %eax, %eax
jg 0x24d1
jmp 0x2548
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x253c
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2548
leaq -0x24(%rbp), %rdx
movq %rbx, %rdi
callq 0x2cf8
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x255a
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x256a
callq 0x20c0
movq %r14, %rdi
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/EverybodyHops[P]Permutations/media_number.cpp
// Function: media_number::add_vector(std::vector<int, std::allocator<int>>)
bool media_number::add_vector(vector<int> v){
    if(!if_vector_legal(v)){
        return false;
    }

    for(int i = 0; i < num.size() - 1; i++){
        if(i < v.size()){  
            num[i] += v[i];
        }
        if(num[i] >= carry[i]){
            num[i] -= carry[i];
            num[i + 1] += 1;
        }
    }

    if(num[num.size() - 1] > 0){
        #ifdef DEBUG
            cout << "Overflow!" << endl;
            print_num();
        #endif
        sub_vector(v);
        #ifdef DEBUG
            cout << "After handle overflow." << endl;
            print_num();
        #endif
        return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x50(%rbp), %r12
movq %r12, %rdi
callq 0x2c2c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2572
movl %eax, %r15d
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2617
callq 0x20c0
testb %r15b, %r15b
je 0x26a2
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
movq %rcx, %rdx
decq %rdx
je 0x2673
movq (%r14), %rsi
movq 0x8(%r14), %rdi
subq %rsi, %rdi
sarq $0x2, %rdi
movq 0x18(%rbx), %r8
xorl %r9d, %r9d
cmpq %r9, %rdi
jbe 0x2658
movl (%rsi,%r9,4), %r10d
addl %r10d, (%rax,%r9,4)
movl (%rax,%r9,4), %r10d
subl (%r8,%r9,4), %r10d
jl 0x266b
movl %r10d, (%rax,%r9,4)
incl 0x4(%rax,%r9,4)
incq %r9
cmpq %r9, %rdx
jne 0x264b
cmpl $0x0, -0x4(%rax,%rcx,4)
jle 0x26b1
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2c2c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x26ce
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x26a2
callq 0x20c0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
jmp 0x26a4
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x26c6
callq 0x20c0
movq %rbx, %rdi
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/EverybodyHops[P]Permutations/media_number.cpp
// Function: media_number::sub_vector(std::vector<int, std::allocator<int>>)
bool media_number::sub_vector(vector<int> v){
    if(!if_vector_legal(v)){
        return false;
    }

    for(int i = 0; i < num.size() - 1; i++){
        if(i < v.size()){  
            num[i] -= v[i];
        }
        if(num[i] < 0){
            num[i] += carry[i];
            num[i + 1] -= 1;
        }
    }

    if(num[num.size() - 1] < 0){
        #ifdef DEBUG
            cout << "Underflow!" << endl;
            print_num();
        #endif
        add_vector(v);
        #ifdef DEBUG
            cout << "After handle unferflow." << endl;
            print_num();
        #endif
        return false;
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x50(%rbp), %r12
movq %r12, %rdi
callq 0x2c2c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2572
movl %eax, %r15d
movq (%r12), %rdi
testq %rdi, %rdi
je 0x270b
callq 0x20c0
testb %r15b, %r15b
je 0x279b
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
movq %rdx, %rax
decq %rax
je 0x276a
movq (%r14), %rsi
movq 0x8(%r14), %rdi
subq %rsi, %rdi
sarq $0x2, %rdi
movq 0x18(%rbx), %r8
xorl %r9d, %r9d
cmpq %r9, %rdi
jbe 0x274c
movl (%rsi,%r9,4), %r10d
subl %r10d, (%rcx,%r9,4)
movl (%rcx,%r9,4), %r10d
testl %r10d, %r10d
jns 0x2762
addl (%r8,%r9,4), %r10d
movl %r10d, (%rcx,%r9,4)
decl 0x4(%rcx,%r9,4)
incq %r9
cmpq %r9, %rax
jne 0x273f
movb $0x1, %al
cmpl $0x0, -0x4(%rcx,%rdx,4)
jns 0x279d
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2c2c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x25da
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x279b
callq 0x20c0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x27bb
callq 0x20c0
movq %rbx, %rdi
callq 0x2140
nop
// File: /workspace/github_cpp_makefile_star2_O1/EverybodyHops[P]Permutations/media_number.cpp
// Function: increase_carry::increase_carry(int)
increase_carry::increase_carry(int digit){
    for(int i = 0; i < digit; i++){
        num.push_back(0);
        carry.push_back(i + 2);
    }
    num.push_back(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
testl %esi, %esi
jle 0x2940
movl %esi, %r14d
leaq 0x18(%rbx), %r15
negl %r14d
movl $0x2, %r12d
leaq -0x30(%rbp), %r13
movl $0x0, -0x34(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x28fb
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2907
movq %rbx, %rdi
leaq -0x34(%rbp), %rdx
callq 0x2e12
movl %r12d, -0x30(%rbp)
movq 0x20(%rbx), %rsi
cmpq 0x28(%rbx), %rsi
je 0x2922
movl %r12d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x20(%rbx)
jmp 0x292d
movq %r15, %rdi
movq %r13, %rdx
callq 0x2e12
leal (%r14,%r12), %eax
incl %eax
movl %r12d, %ecx
incl %ecx
movl %ecx, %r12d
cmpl $0x2, %eax
jne 0x28da
movl $0x0, -0x2c(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2961
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x296d
leaq -0x2c(%rbp), %rdx
movq %rbx, %rdi
callq 0x2e12
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2980
jmp 0x2980
movq %rax, %r14
movq %rbx, %rdi
callq 0x2cac
movq %r14, %rdi
callq 0x2140
nop
// File: /workspace/github_cpp_makefile_star2_O1/EverybodyHops[P]Permutations/media_number.cpp
// Function: increase_carry::increase_carry(std::vector<int, std::allocator<int>>)
increase_carry::increase_carry(vector<int> _num){
    num.assign(_num.begin(), _num.end());
    for(int i = 0; i < num.size(); i++){
        carry.push_back(i + 2);
    }
    num.push_back(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq %rax, %rsi
callq 0x2ee6
movq 0x8(%rbx), %rsi
cmpq (%rbx), %rsi
je 0x2a1b
leaq 0x18(%rbx), %r14
xorl %r12d, %r12d
leaq -0x28(%rbp), %r15
leal 0x2(%r12), %eax
movl %eax, -0x28(%rbp)
movq 0x20(%rbx), %rsi
cmpq 0x28(%rbx), %rsi
je 0x29fa
leal 0x2(%r12), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x20(%rbx)
jmp 0x2a05
movq %r14, %rdi
movq %r15, %rdx
callq 0x2e12
incq %r12
movq 0x8(%rbx), %rsi
movq %rsi, %rax
subq (%rbx), %rax
sarq $0x2, %rax
cmpq %r12, %rax
ja 0x29d7
movl $0x0, -0x24(%rbp)
cmpq 0x10(%rbx), %rsi
je 0x2a38
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2a44
leaq -0x24(%rbp), %rdx
movq %rbx, %rdi
callq 0x2e12
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a55
jmp 0x2a55
movq %rax, %r14
movq %rbx, %rdi
callq 0x2cac
movq %r14, %rdi
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/EverybodyHops[P]Permutations/media_number.cpp
// Function: decrease_carry::decrease_carry(int)
decrease_carry::decrease_carry(int digit){
    for(int i = 0; i < digit; i++){
        num.push_back(0);
        carry.push_back(digit + 1 - i);
    }
    num.push_back(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
testl %esi, %esi
jle 0x2afb
movl %esi, %r14d
incl %r14d
leaq 0x18(%rbx), %r15
leaq -0x34(%rbp), %r12
leaq -0x30(%rbp), %r13
movl $0x0, -0x34(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2ac1
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2acc
movq %rbx, %rdi
movq %r12, %rdx
callq 0x2e12
movl %r14d, -0x30(%rbp)
movq 0x20(%rbx), %rsi
cmpq 0x28(%rbx), %rsi
je 0x2ae7
movl %r14d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x20(%rbx)
jmp 0x2af2
movq %r15, %rdi
movq %r13, %rdx
callq 0x2e12
decl %r14d
cmpl $0x1, %r14d
jne 0x2aa0
movl $0x0, -0x2c(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2b1c
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2b28
leaq -0x2c(%rbp), %rdx
movq %rbx, %rdi
callq 0x2e12
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b3b
jmp 0x2b3b
movq %rax, %r14
movq %rbx, %rdi
callq 0x2cac
movq %r14, %rdi
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/EverybodyHops[P]Permutations/media_number.cpp
// Function: decrease_carry::decrease_carry(std::vector<int, std::allocator<int>>)
decrease_carry::decrease_carry(vector<int> _num){
    num.assign(_num.begin(), _num.end());
    for(int i = 0; i < num.size(); i++){
        carry.push_back(num.size() - i + 1);
    }
    num.push_back(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq %rax, %rsi
callq 0x2ee6
movq 0x8(%rbx), %rsi
movq %rsi, %rax
subq (%rbx), %rax
je 0x2bdd
sarq $0x2, %rax
leaq 0x18(%rbx), %r14
movl $0x1, %r12d
xorl %r13d, %r13d
leaq -0x30(%rbp), %r15
addl %r12d, %eax
movl %eax, -0x30(%rbp)
movq 0x20(%rbx), %rsi
cmpq 0x28(%rbx), %rsi
je 0x2bb9
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x20(%rbx)
jmp 0x2bc4
movq %r14, %rdi
movq %r15, %rdx
callq 0x2e12
movq 0x8(%rbx), %rsi
movq %rsi, %rax
subq (%rbx), %rax
incq %r13
sarq $0x2, %rax
decl %r12d
cmpq %r13, %rax
ja 0x2b9d
movl $0x0, -0x2c(%rbp)
cmpq 0x10(%rbx), %rsi
je 0x2bfa
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2c06
leaq -0x2c(%rbp), %rdx
movq %rbx, %rdi
callq 0x2e12
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2c19
jmp 0x2c19
movq %rax, %r14
movq %rbx, %rdi
callq 0x2cac
movq %r14, %rdi
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/EverybodyHops[P]Permutations/./debug.h
// Function: void print_vector<char>(std::vector<char, std::allocator<char>>, bool)
void print_vector(vector<T> a, bool if_reverse=false){
    if(if_reverse){
        reverse(a.begin(), a.end());
    }
    for(auto x: a){
        cout << x << " ";
    }
    cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
je 0x49f3
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
cmpq %rcx, %rax
setne %dl
decq %rcx
cmpq %rax, %rcx
seta %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x49f3
incq %rax
movb -0x1(%rax), %dl
movb (%rcx), %sil
movb %sil, -0x1(%rax)
movb %dl, (%rcx)
decq %rcx
leaq 0x1(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jb 0x49d8
movq (%rdi), %r12
movq 0x8(%rdi), %r13
cmpq %r13, %r12
je 0x4a40
movq 0x45d2(%rip), %rbx      # 0x8fd8
leaq -0x29(%rbp), %r14
leaq 0x15fb(%rip), %r15      # 0x600c
movb (%r12), %al
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20f0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x20f0
incq %r12
cmpq %r13, %r12
jne 0x4a11
movq 0x4591(%rip), %rbx      # 0x8fd8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2080
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/EverybodyHops[P]Permutations/./permutations.hpp
// Function: dic_order<int>::get_permutation()
vector<T> get_permutation() override{
        int len = this->ordered_element.size();
        bool *can_use = new bool[len];
        for(int i = 0; i < this->ordered_element.size(); i++){
            can_use[i] = true;
        }

        vector<int> m_num = this->media_num->get_num();
        m_num.insert(m_num.begin(), 0);
        
        vector<T> res;
        int temp;
        for(int i = m_num.size() - 1; i >= 0; i--){
            temp = m_num[i];
            for(int j = 0; j < len; j++){
                if(can_use[j]){
                    if(temp == 0){
                        res.push_back(this->ordered_element[j]);
                        can_use[j] = false;
                        break; 
                    }else{
                        temp -= 1;
                    }
                }
            }
        }
        delete[] can_use;
        return res;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, -0x30(%rbp)
movq 0x18(%rsi), %rbx
movq %rsi, -0x38(%rbp)
movq 0x10(%rsi), %r12
movq %rbx, %rax
subq %r12, %rax
movq %rax, %r14
sarq $0x2, %r14
shrq $0x2, %rax
cltq
testq %rax, %rax
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, %r15
cmpq %r12, %rbx
je 0x3a69
cmpq $0x1, %r14
movq %r14, %rdx
adcq $0x0, %rdx
movq %r15, %rdi
movl $0x1, %esi
callq 0x2070
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x50(%rbp), %r12
movq %r12, %rdi
callq 0x22dc
movq (%r12), %rsi
leaq -0x54(%rbp), %rdx
movl $0x0, (%rdx)
movq %r12, %rdi
callq 0x5226
xorps %xmm0, %xmm0
movq -0x30(%rbp), %rdi
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq -0x48(%rbp), %rax
subq -0x50(%rbp), %rax
shrq $0x2, %rax
decl %eax
js 0x3b2d
movl %eax, %r12d
movl %r14d, %r13d
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
testl %r14d, %r14d
jle 0x3b20
movq -0x50(%rbp), %rax
movl (%rax,%r12,4), %ecx
xorl %eax, %eax
xorl %ebx, %ebx
cmpb $0x1, (%r15,%rbx)
jne 0x3ae0
testl %ecx, %ecx
je 0x3aee
decl %ecx
incq %rbx
addq $-0x4, %rax
cmpq %rbx, %r13
jne 0x3ad3
jmp 0x3b20
movq -0x38(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x3b0f
movl (%rdx,%rbx,4), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x3b17
subq %rax, %rdx
callq 0x2cf8
movb $0x0, (%r15,%rbx)
movq -0x30(%rbp), %rdi
leaq -0x1(%r12), %rax
testq %r12, %r12
movq %rax, %r12
jg 0x3ac2
movq %r15, %rdi
callq 0x2100
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3b43
callq 0x20c0
movq -0x30(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x3b6f
movq %rax, %r14
movq -0x30(%rbp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3b6f
callq 0x20c0
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3b7d
callq 0x20c0
movq %r14, %rdi
callq 0x2140
nop
// File: /workspace/github_cpp_makefile_star2_O1/EverybodyHops[P]Permutations/./permutations.hpp
// Function: increase_carry_order<int>::increase_carry_order(std::vector<int, std::allocator<int>>)
increase_carry_order(vector<T> init_per){
        this->ordered_element = init_per;
        sort(this->ordered_element.begin(), this->ordered_element.end());

        //permutation to media number
        vector<int> t;
        int temp;
        for(int i = 1; i < this->ordered_element.size(); i++){
            temp = 0;
            for(int j = init_per.size() - 1; j >= 0; j--){
                if(init_per[j] < this->ordered_element[i]){
                    temp += 1;
                }
                if(init_per[j] == this->ordered_element[i]){
                    break;
                }
            }
            t.push_back(temp);
        }
        this->media_num = new increase_carry(t);

        #ifdef DEBUG
            this->media_num->print_num();
        #endif
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x10, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x20(%rbx)
leaq 0x5151(%rip), %rax      # 0x8d08
movq %rax, (%rbx)
callq 0x4dd6
movq 0x10(%rbx), %r15
movq 0x18(%rbx), %r12
cmpq %r12, %r15
je 0x3bf9
movq %r12, %rax
subq %r15, %rax
sarq $0x2, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x4eae
movq %r15, %rdi
movq %r12, %rsi
callq 0x4f8f
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
subq %rax, %rcx
cmpq $0x5, %rcx
jb 0x3ca9
movl $0x1, %r13d
leaq -0x50(%rbp), %r15
leaq -0x2c(%rbp), %r12
movl $0x0, -0x2c(%rbp)
movq (%r14), %rcx
movq 0x8(%r14), %rsi
subq %rcx, %rsi
shrq $0x2, %rsi
xorl %edx, %edx
movl %esi, %esi
decq %rsi
testl %esi, %esi
js 0x3c6e
movl %esi, %edi
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
movl (%rcx,%rdi,4), %r8d
cmpl (%rax,%r13,4), %r8d
jge 0x3c62
incl %edx
movl %edx, -0x2c(%rbp)
movl (%rcx,%rdi,4), %edi
decq %rsi
cmpl (%rax,%r13,4), %edi
jne 0x3c47
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x3c87
movl -0x2c(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x3c92
movq %r15, %rdi
movq %r12, %rdx
callq 0x2cf8
incq %r13
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
ja 0x3c2b
movl $0x30, %edi
callq 0x20e0
movq %rax, %r15
leaq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2c2c
leaq -0x68(%rbp), %rsi
movq %r15, %rdi
callq 0x2994
movq %r15, 0x8(%rbx)
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x3ce1
callq 0x20c0
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3cef
callq 0x20c0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x3d14
callq 0x20c0
jmp 0x3d14
movq %rax, %r14
movq %r15, %rdi
callq 0x20c0
jmp 0x3d28
jmp 0x3d25
movq %rax, %r14
jmp 0x3d36
movq %rax, %r14
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3d36
callq 0x20c0
movq %rbx, %rdi
callq 0x4cf2
movq %r14, %rdi
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/EverybodyHops[P]Permutations/./permutations.hpp
// Function: increase_carry_order<int>::get_permutation()
vector<T> get_permutation() override{
        int len = this->ordered_element.size();
        bool *can_put = new bool[len];
        for(int i = 0; i < this->ordered_element.size(); i++){
            can_put[i] = true;
        }

        vector<int> m_num = this->media_num->get_num();
        m_num.insert(m_num.begin(), 0);

        vector<T> res(len);
        int temp;
        for(int i = m_num.size() - 1; i >= 0; i--){
            temp = m_num[i];
            for(int j = 0; j < len; j++){
                if(can_put[j]){
                    if(temp == 0){
                        res[j] = this->ordered_element[i];
                        can_put[j] = false;
                        break; 
                    }else{
                        temp -= 1;
                    }
                }
            }
        }
        delete[] can_put;
        reverse(res.begin(), res.end());
        return res;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, -0x40(%rbp)
movq 0x18(%rsi), %r13
movq %rsi, -0x38(%rbp)
movq 0x10(%rsi), %r15
movq %r13, %rax
subq %r15, %rax
movq %rax, %rbx
sarq $0x2, %rbx
shrq $0x2, %rax
movslq %eax, %r12
testq %r12, %r12
movq $-0x1, %rdi
cmovnsq %r12, %rdi
callq 0x2030
movq %rax, %r14
cmpq %r15, %r13
je 0x3dae
cmpq $0x1, %rbx
movq %rbx, %rdx
adcq $0x0, %rdx
movq %r14, %rdi
movl $0x1, %esi
callq 0x2070
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x58(%rbp), %r13
movq %r13, %rdi
callq 0x22dc
movq (%r13), %rsi
leaq -0x2c(%rbp), %rdx
movl $0x0, (%rdx)
movq %r13, %rdi
callq 0x5226
leaq -0x2c(%rbp), %rdx
movq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x52ac
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rsi
subq %rax, %rsi
shrq $0x2, %rsi
decl %esi
js 0x3e50
movq -0x38(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq (%r15), %rdx
movl %esi, %esi
movl %ebx, %edi
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
testl %ebx, %ebx
jle 0x3e44
movl (%rax,%rsi,4), %r9d
xorl %r8d, %r8d
cmpb $0x1, (%r14,%r8)
jne 0x3e2d
testl %r9d, %r9d
je 0x3e37
decl %r9d
incq %r8
cmpq %r8, %rdi
jne 0x3e1e
jmp 0x3e44
movl (%rcx,%rsi,4), %r9d
movl %r9d, (%rdx,%r8,4)
movb $0x0, (%r14,%r8)
leaq -0x1(%rsi), %r8
testq %rsi, %rsi
movq %r8, %rsi
jg 0x3e13
movq %r14, %rdi
callq 0x2100
movq (%r15), %rax
movq 0x8(%r15), %rcx
cmpq %rcx, %rax
setne %dl
addq $-0x4, %rcx
cmpq %rax, %rcx
seta %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x3e97
addq $0x4, %rax
movl -0x4(%rax), %edx
movl (%rcx), %esi
movl %esi, -0x4(%rax)
movl %edx, (%rcx)
addq $-0x4, %rcx
leaq 0x4(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jb 0x3e7d
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x3ea5
callq 0x20c0
movq %r15, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3eb9
movq %rax, %rbx
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x3eca
callq 0x20c0
movq %rbx, %rdi
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/EverybodyHops[P]Permutations/./permutations.hpp
// Function: permutations<char>::~permutations()
~permutations(){
        #ifdef DEBUG
            cout << "release media_num." << endl;
        #endif
        delete media_num;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x3fdd(%rip), %rax      # 0x8c88
movq %rax, (%rdi)
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x4cda
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x4cc5
callq 0x20c0
movq (%r14), %rdi
testq %rdi, %rdi
je 0x4cd2
callq 0x20c0
movq %r14, %rdi
callq 0x20c0
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x4cec
popq %rbx
popq %r14
popq %rbp
jmp 0x20c0
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tsl_hopscotch_map/test-1.cpp
// Function: test_int(unsigned int, unsigned int)
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	tsl::bhopscotch_map<uint32_t, uint32_t, Hash32> h;
	for (i = 0, x = x0; i < n; ++i) {
		x = hash32(x);
#ifndef UDB2_TEST_DEL
		z += ++h[get_key(n, x)];
#else
		auto p = h.insert(std::pair<uint32_t, uint32_t>(get_key(n, x), i));
		if (p.second == false) h.erase(p.first);
#endif
	}
	fprintf(stderr, "# unique keys: %ld; checksum: %u\n", h.size(), z);
	return h.size();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movl %esi, %ebp
movl %edi, %r14d
xorl %r13d, %r13d
leaq 0x80(%rsp), %rdi
leaq 0x40(%rsp), %rdx
leaq 0x20(%rsp), %rcx
leaq 0x68(%rsp), %r8
movss 0x1915(%rip), %xmm0     # 0x3020
leaq 0x1f(%rsp), %r9
xorl %esi, %esi
callq 0x18c2
testl %r14d, %r14d
je 0x17ed
movl %r14d, %ebx
shrl $0x2, %ebx
leaq 0x80(%rsp), %r15
leaq 0x20(%rsp), %r12
movl %ebp, %eax
shll $0xf, %eax
notl %eax
addl %ebp, %eax
movl %eax, %ecx
shrl $0xa, %ecx
xorl %eax, %ecx
leal (%rcx,%rcx,8), %eax
movl %eax, %ecx
shrl $0x6, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shll $0xb, %eax
notl %eax
addl %ecx, %eax
movl %eax, %ebp
shrl $0x10, %ebp
xorl %eax, %ebp
movl %ebp, %eax
xorl %edx, %edx
divl %ebx
movl %edx, %eax
shll $0xf, %eax
notl %eax
addl %edx, %eax
movl %eax, %ecx
shrl $0xa, %ecx
xorl %eax, %ecx
leal (%rcx,%rcx,8), %eax
movl %eax, %ecx
shrl $0x6, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shll $0xb, %eax
notl %eax
addl %ecx, %eax
movl %eax, %ecx
shrl $0x10, %ecx
xorl %eax, %ecx
movl %ecx, 0x20(%rsp)
movl %r13d, 0x24(%rsp)
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1caa
cmpb $0x0, 0x58(%rsp)
jne 0x17e1
movq 0x50(%rsp), %rax
movaps 0x40(%rsp), %xmm0
movaps %xmm0, 0x20(%rsp)
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x68(%rsp), %rdi
movq %r15, %rsi
callq 0x2704
incl %r13d
cmpl %r13d, %r14d
jne 0x1733
leaq 0x80(%rsp), %rdi
leaq 0x40(%rsp), %rbx
movq %rbx, %rsi
callq 0x14e8
movl (%rbx), %eax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1818
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x1830
movq %rbx, %rdi
callq 0x11d0
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tsl_hopscotch_map/./hopscotch_hash.h
// Function: std::pair<tsl::detail_hopscotch_hash::hopscotch_hash<std::pair<unsigned int const, unsigned int>, tsl::bhopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::KeySelect, tsl::bhopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::ValueSelect, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>, std::map<unsigned int, unsigned int, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>>::hopscotch_iterator<false>, bool> tsl::detail_hopscotch_hash::hopscotch_hash<std::pair<unsigned int const, unsigned int>, tsl::bhopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::KeySelect, tsl::bhopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::ValueSelect, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>, std::map<unsigned int, unsigned int, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>>::insert_impl<std::pair<unsigned int const, unsigned int>>(std::pair<unsigned int const, unsigned int>&&)
std::pair<iterator, bool> insert_impl(P&& value) {
        const std::size_t hash = hash_key(KeySelect()(value));
        const std::size_t ibucket_for_hash = bucket_for_hash(hash);
        
        // Check if already presents
        auto it_find = find_impl(KeySelect()(value), hash, m_buckets + ibucket_for_hash);
        if(it_find != end()) {
            return std::make_pair(it_find, false);
        }
        
        
        return insert_value(ibucket_for_hash, hash, std::forward<P>(value));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl (%rdx), %r12d
movl (%rsi), %r13d
andl %r12d, %r13d
movq %r13, %r8
shlq $0x4, %r8
addq 0x50(%rsi), %r8
movq %rsp, %rbp
movq %rbp, %rdi
movq %r12, %rcx
callq 0x1d34
movq (%rbp), %rax
cmpq 0x10(%r15), %rax
jne 0x1d0e
leaq 0x28(%r15), %rax
cmpq %rax, 0x10(%rsp)
jne 0x1d0e
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r14, %r8
callq 0x1de0
jmp 0x1d22
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
movups (%rsp), %xmm0
movups %xmm0, (%rbx)
movb $0x0, 0x18(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tsl_hopscotch_map/./hopscotch_hash.h
// Function: tsl::detail_hopscotch_hash::hopscotch_hash<std::pair<unsigned int const, unsigned int>, tsl::bhopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::KeySelect, tsl::bhopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::ValueSelect, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>, std::map<unsigned int, unsigned int, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>>::will_neighborhood_change_on_rehash(unsigned long) const
bool will_neighborhood_change_on_rehash(size_t ibucket_neighborhood_check) const {
        std::size_t expand_bucket_count = GrowthPolicy::next_bucket_count();
        GrowthPolicy expand_growth_policy(expand_bucket_count);
        
        const bool use_stored_hash = USE_STORED_HASH_ON_REHASH(expand_bucket_count);
        for(size_t ibucket = ibucket_neighborhood_check; 
            ibucket < m_buckets_data.size() && (ibucket - ibucket_neighborhood_check) < NeighborhoodSize; 
            ++ibucket)
        {
            tsl_hh_assert(!m_buckets[ibucket].empty());
            
            const size_t hash = use_stored_hash?
                                    m_buckets[ibucket].truncated_bucket_hash():
                                    hash_key(KeySelect()(m_buckets[ibucket].value()));
            if(bucket_for_hash(hash) != expand_growth_policy.bucket_for_hash(hash)) {
                return true;
            }
        }
        
        return false;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1fea
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x252a
movq 0x10(%r14), %rcx
subq 0x8(%r14), %rcx
sarq $0x4, %rcx
cmpq %rbx, %rcx
seta %al
jbe 0x21b2
movq 0x50(%r14), %rsi
movq 0x8(%rsp), %rdx
xorq (%r14), %rdx
movq %rbx, %rdi
shlq $0x4, %rdi
testl %edx, 0x8(%rsi,%rdi)
jne 0x21b2
addq %rsi, %rdi
addq $0x18, %rdi
movl $0x1, %esi
leaq (%rbx,%rsi), %rax
cmpq %rcx, %rax
setb %r8b
cmpq $0x3e, %rsi
setb %al
andb %r8b, %al
cmpb $0x1, %al
jne 0x21b2
leaq 0x10(%rdi), %r8
incq %rsi
testl %edx, (%rdi)
movq %r8, %rdi
je 0x218b
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tsl_hopscotch_map/./hopscotch_hash.h
// Function: tsl::detail_hopscotch_hash::hopscotch_hash<std::pair<unsigned int const, unsigned int>, tsl::bhopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::KeySelect, tsl::bhopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::ValueSelect, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>, std::map<unsigned int, unsigned int, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>>::erase_from_bucket(tsl::detail_hopscotch_hash::hopscotch_bucket<std::pair<unsigned int const, unsigned int>, 62u, false>&, unsigned long)
void erase_from_bucket(hopscotch_bucket& bucket_for_value, std::size_t ibucket_for_hash) noexcept {
        const std::size_t ibucket_for_value = std::distance(m_buckets_data.data(), &bucket_for_value);
        tsl_hh_assert(ibucket_for_value >= ibucket_for_hash);
        
        bucket_for_value.remove_value();
        m_buckets[ibucket_for_hash].toggle_neighbor_presence(ibucket_for_value - ibucket_for_hash);
        m_nb_elements--;
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rdi), %rax
movq (%rsi), %rsi
testb $0x1, %sil
je 0x237d
andq $-0x2, %rsi
movq %rsi, (%rcx)
subl %eax, %ecx
shrl $0x4, %ecx
movq 0x50(%rdi), %rax
movq %rdx, %rsi
subl %edx, %ecx
addb $0x2, %cl
movl $0x1, %edx
shlq %cl, %rdx
shlq $0x4, %rsi
xorq %rdx, (%rax,%rsi)
decq 0x58(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tsl_hopscotch_map/./hopscotch_growth_policy.h
// Function: tsl::hh::power_of_two_growth_policy<2ul>::power_of_two_growth_policy(unsigned long&)
explicit power_of_two_growth_policy(std::size_t& min_bucket_count_in_out) {
        if(min_bucket_count_in_out > max_bucket_count()) {
            throw std::length_error("The hash table exceeds its maxmimum size.");
        }
        
        if(min_bucket_count_in_out > 0) {
            min_bucket_count_in_out = round_up_to_power_of_two(min_bucket_count_in_out);
            m_mask = min_bucket_count_in_out - 1;
        }
        else {
            m_mask = 0;
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rsi), %rax
movabsq $-0x7fffffffffffffff, %rcx # imm = 0x8000000000000001
cmpq %rcx, %rax
jae 0x2588
testq %rax, %rax
je 0x257b
leaq -0x1(%rax), %rdx
movl $0x1, %ecx
testq %rdx, %rax
cmovneq %rcx, %rax
je 0x2573
movq %rdx, %rax
shrq %cl, %rdx
orq %rax, %rdx
leaq (%rcx,%rcx), %rax
cmpq $0x20, %rcx
movq %rax, %rcx
jb 0x2557
incq %rdx
movq %rdx, %rax
movq %rax, (%rsi)
decq %rax
jmp 0x257d
xorl %eax, %eax
movq %rax, (%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x1090
movq %rax, %rbx
leaq 0xb4e(%rip), %rsi       # 0x30ea
movq %rax, %rdi
callq 0x1160
movq 0x2a35(%rip), %rsi      # 0x4fe0
movq 0x2a1e(%rip), %rdx      # 0x4fd0
movq %rbx, %rdi
callq 0x11c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x1100
movq %r14, %rdi
callq 0x11d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tsl_hopscotch_map/./hopscotch_hash.h
// Function: tsl::detail_hopscotch_hash::hopscotch_hash<std::pair<unsigned int const, unsigned int>, tsl::bhopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::KeySelect, tsl::bhopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::ValueSelect, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>, std::map<unsigned int, unsigned int, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>>::erase_from_overflow(std::_Rb_tree_const_iterator<std::pair<unsigned int const, unsigned int>>, unsigned long)
iterator_overflow erase_from_overflow(const_iterator_overflow pos, std::size_t ibucket_for_hash) {
#ifdef TSL_HH_NO_RANGE_ERASE_WITH_CONST_ITERATOR        
        auto it_next = m_overflow_elements.erase(mutable_overflow_iterator(pos));
#else
        auto it_next = m_overflow_elements.erase(pos);
#endif
        m_nb_elements--;
        
        
        // Check if we can remove the overflow flag
        tsl_hh_assert(m_buckets[ibucket_for_hash].has_overflow());
        for(const value_type& value: m_overflow_elements) {
            const std::size_t bucket_for_value = bucket_for_hash(hash_key(KeySelect()(value)));
            if(bucket_for_value == ibucket_for_hash) {
                return it_next;
            }
        }
        
        m_buckets[ibucket_for_hash].set_overflow(false);
        return it_next;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x20(%rdi), %r15
callq 0x2814
movq %r15, %rdi
movq %rax, %rsi
callq 0x2872
movq %rax, %r15
decq 0x58(%r14)
movq 0x38(%r14), %rax
leaq 0x28(%r14), %r12
cmpq %r12, %rax
sete %cl
je 0x27fa
movq (%r14), %r13
movl 0x20(%rax), %edx
andl %r13d, %edx
cmpq %rbx, %rdx
je 0x27f6
movq %rax, %rdi
callq 0x10f0
cmpq %r12, %rax
sete %cl
jne 0x27d9
jmp 0x27fa
testb %cl, %cl
je 0x2807
movq 0x50(%r14), %rax
shlq $0x4, %rbx
andq $-0x3, (%rax,%rbx)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/wekan[P]sps/sps.cxx
// Function: tokenize_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
vector_string_t tokenize_string(const std::string & source_string, const char separator)
{
	vector_string_t l;
	std::string s;
	std::istringstream i (source_string);

	std::getline(i, s, separator);

	while (!i.eof())
	{
		l.insert (l.end(), s);
		std::getline(i, s, separator);
	}

	if (s != "")
	{
		l.insert (l.end(), s);
	}

	return l;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movl %edx, %ebp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x20(%rsp), %rdi
movl $0x8, %edx
callq 0x2280
movsbl %bpl, %ebp
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movl %ebp, %edx
callq 0x22b0
movq %rsp, %r14
leaq 0x20(%rsp), %r15
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x40(%rsp,%rax)
jne 0x255d
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3dfc
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x22b0
jmp 0x252f
leaq 0x2bd8(%rip), %rsi      # 0x513c
movq %rsp, %rdi
callq 0x2080
testl %eax, %eax
je 0x257f
movq 0x8(%rbx), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x3dfc
movq 0x4a42(%rip), %rsi      # 0x6fc8
leaq 0x20(%rsp), %rdi
callq 0x2220
leaq 0x98(%rsp), %rdi
callq 0x20b0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x25b3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x25d1
jmp 0x25d1
movq %rax, %r14
jmp 0x25f2
jmp 0x25d1
movq %rax, %r14
movq 0x49ed(%rip), %rsi      # 0x6fc8
leaq 0x20(%rsp), %rdi
callq 0x2220
leaq 0x98(%rsp), %rdi
callq 0x20b0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2608
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x3ed4
movq %r14, %rdi
callq 0x2290