LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: quancs[P]EAVC/./eavc.h
// Function: choose_remove_v()
unsigned int choose_remove_v() {
    unsigned int i, v;

    unsigned int best_v = cVertexes[static_cast<unsigned int>(pcg32_fast()) % cvSize];
    if (static_cast<unsigned int>(pcg32_fast()) % 10 < 9) {
        for (i = 1; i < cand_count; ++i) {
            v = cVertexes[static_cast<unsigned int>(pcg32_fast()) % cvSize];

            if (dscore[v] < dscore[best_v])
                continue;
            else if (dscore[v] > dscore[best_v])
                best_v = v;
            else if (vTimestamp[v] < vTimestamp[best_v]) {
                best_v = v;
            }
        }
    }

    return best_v;
}

// Assembly:
subq $0x28, %rsp
movq 0x780d(%rip), %rax      # 0xb198
movq %rax, 0x10(%rsp)
callq 0x2410
xorl %edx, %edx
divl 0x7853(%rip)            # 0xb1f0
movq 0x10(%rsp), %rax
movl %edx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, 0x1c(%rsp)
callq 0x2410
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
cmpl $0x9, %edx
jae 0x3a87
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x774c(%rip), %eax      # 0xb120
jae 0x3a85
movq 0x77b7(%rip), %rax      # 0xb198
movq %rax, 0x8(%rsp)
callq 0x2410
xorl %edx, %edx
divl 0x77fd(%rip)            # 0xb1f0
movq 0x8(%rsp), %rax
movl %edx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, 0x20(%rsp)
movq 0x7760(%rip), %rax      # 0xb168
movl 0x20(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movq 0x7752(%rip), %rcx      # 0xb168
movl 0x1c(%rsp), %edx
cmpl (%rcx,%rdx,4), %eax
jge 0x3a21
jmp 0x3a75
movq 0x7740(%rip), %rax      # 0xb168
movl 0x20(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movq 0x7732(%rip), %rcx      # 0xb168
movl 0x1c(%rsp), %edx
cmpl (%rcx,%rdx,4), %eax
jle 0x3a49
movl 0x20(%rsp), %eax
movl %eax, 0x1c(%rsp)
jmp 0x3a71
movq 0x7720(%rip), %rax      # 0xb170
movl 0x20(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movq 0x7712(%rip), %rcx      # 0xb170
movl 0x1c(%rsp), %edx
cmpl (%rcx,%rdx,4), %eax
jae 0x3a6f
movl 0x20(%rsp), %eax
movl %eax, 0x1c(%rsp)
jmp 0x3a71
jmp 0x3a73
jmp 0x3a75
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x39ca
jmp 0x3a87
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
// File: quancs[P]EAVC/./eavc.h
// Function: add(unsigned int)
void add(unsigned int v) {
    vInC[v] = IN;
    dscore[v] = -dscore[v];

    unsigned int i, e, n;

    unsigned int edgeCount = dVDegree[v];

    for (i = 0; i < edgeCount; ++i) {
        e = vEdges[v][i];// v's i'th edge
        n = vAdj[v][i];//v's i'th neighbor

        if (not_in(vInC, n)) { //this adj isn't in cover set
            dscore[n]--;
            //conf_change[n] = 1;

            cover(e);
        } else {
            dscore[n]++;
        }
    }

}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq 0x58e1(%rip), %rax      # 0xb190
movl 0x14(%rsp), %ecx
movb $0x3, (%rax,%rcx)
movq 0x58aa(%rip), %rax      # 0xb168
movl 0x14(%rsp), %ecx
xorl %edx, %edx
subl (%rax,%rcx,4), %edx
movq 0x589a(%rip), %rax      # 0xb168
movl 0x14(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movq 0x58d4(%rip), %rax      # 0xb1b0
movl 0x14(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, 0x4(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x4(%rsp), %eax
jae 0x598c
movq 0x5874(%rip), %rax      # 0xb178
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl 0x10(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, 0xc(%rsp)
movq 0x5862(%rip), %rax      # 0xb180
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl 0x10(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, 0x8(%rsp)
movq 0x5858(%rip), %rdi      # 0xb190
movl 0x8(%rsp), %esi
callq 0x72f0
testb $0x1, %al
jne 0x5947
jmp 0x5966
movq 0x581a(%rip), %rax      # 0xb168
movl 0x8(%rsp), %ecx
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
movl %edx, (%rax,%rcx,4)
movl 0xc(%rsp), %edi
callq 0x7320
jmp 0x597a
movq 0x57fb(%rip), %rax      # 0xb168
movl 0x8(%rsp), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x597c
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x58ef
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: quancs[P]EAVC/./eavc.h
// Function: print_solution()
void print_solution() {
    for (unsigned int i = 0; i < vNum; i++) {
        if (in(vInBest, i)) //output vertex cover
            cout << (i + 1) << '\t';
    }
    cout << endl;
}

// Assembly:
pushq %rax
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x5789(%rip), %eax      # 0xb13c
jae 0x59fa
movq 0x57ec(%rip), %rdi      # 0xb1a8
movl 0x4(%rsp), %esi
callq 0x72c0
testb $0x1, %al
jne 0x59cb
jmp 0x59eb
movl 0x4(%rsp), %esi
addl $0x1, %esi
movq 0x55ff(%rip), %rdi      # 0xafd8
callq 0x2180
movq %rax, %rdi
movl $0x9, %esi
callq 0x2150
jmp 0x59ed
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x59a9
movq 0x55d7(%rip), %rdi      # 0xafd8
movq 0x55c0(%rip), %rsi      # 0xafc8
callq 0x2140
popq %rax
retq
nop
// File: quancs[P]EAVC/./eavc.h
// Function: check_solution()
int check_solution() {
    for (unsigned int e = 0; e < eNum; ++e) {
        if (!in(vInBest, edges[e].v1) && !in(vInBest, edges[e].v2)) {
            cout << "c error: uncovered edge " << e << endl;
            return 0;
        }
    }

    unsigned int verified_vc_size = 0;
    for (unsigned int i = 0; i < vNum; i++) {
        if (in(vInBest, i))
            verified_vc_size++;
    }

    if (bestSize == verified_vc_size)
        return 1;
    else {
        cout << "c error: claimed best found vc size!=verified vc size" << endl;
        cout << "c claimed best found vc size=" << bestSize << endl;
        cout << "c verified vc size=" << verified_vc_size << endl;
        return 0;
    }
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x571a(%rip), %eax      # 0xb140
jae 0x5ab6
movq 0x5775(%rip), %rdi      # 0xb1a8
movq 0x5716(%rip), %rax      # 0xb150
movl 0x10(%rsp), %ecx
movl (%rax,%rcx,8), %esi
callq 0x72c0
testb $0x1, %al
jne 0x5aa4
movq 0x5757(%rip), %rdi      # 0xb1a8
movq 0x56f8(%rip), %rax      # 0xb150
movl 0x10(%rsp), %ecx
movl 0x4(%rax,%rcx,8), %esi
callq 0x72c0
testb $0x1, %al
jne 0x5aa4
movq 0x5568(%rip), %rdi      # 0xafd8
leaq 0x268c(%rip), %rsi      # 0x8103
callq 0x2130
movq %rax, %rdi
movl 0x10(%rsp), %esi
callq 0x2180
movq %rax, %rdi
movq 0x5536(%rip), %rsi      # 0xafc8
callq 0x2140
movl $0x0, 0x14(%rsp)
jmp 0x5ba3
jmp 0x5aa6
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x5a1c
movl $0x0, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x566c(%rip), %eax      # 0xb13c
jae 0x5b02
movq 0x56cf(%rip), %rdi      # 0xb1a8
movl 0x8(%rsp), %esi
callq 0x72c0
testb $0x1, %al
jne 0x5ae8
jmp 0x5af3
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x5af5
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x5ac6
movl 0x56f0(%rip), %eax      # 0xb1f8
cmpl 0xc(%rsp), %eax
jne 0x5b1b
movl $0x1, 0x14(%rsp)
jmp 0x5ba3
movq 0x54b6(%rip), %rdi      # 0xafd8
leaq 0x25f3(%rip), %rsi      # 0x811c
callq 0x2130
movq %rax, %rdi
movq 0x5490(%rip), %rsi      # 0xafc8
callq 0x2140
movq 0x5494(%rip), %rdi      # 0xafd8
leaq 0x2607(%rip), %rsi      # 0x8152
callq 0x2130
movq %rax, %rdi
movl 0x569f(%rip), %esi      # 0xb1f8
callq 0x2180
movq %rax, %rdi
movq 0x5460(%rip), %rsi      # 0xafc8
callq 0x2140
movq 0x5464(%rip), %rdi      # 0xafd8
leaq 0x25f5(%rip), %rsi      # 0x8170
callq 0x2130
movq %rax, %rdi
movl 0xc(%rsp), %esi
callq 0x2180
movq %rax, %rdi
movq 0x5432(%rip), %rsi      # 0xafc8
callq 0x2140
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: quancs[P]EAVC/./eavc.h
// Function: prep_handle_degree_1(unsigned int)
inline bool prep_handle_degree_1(unsigned v) {
    // set adj as an necessary vertice
    unsigned adj = vAdj[v][0];
    vInBest[adj] = IN_ABS;
    total_IN_ABS++;

    // !important the sequence cannot be changed
    prep_remove_from_neighbours(adj); //remove adj from all its neighbours

    // set v as an unnecessary vertice
    vInBest[v] = NIN_ABS;
    total_NIN_ABS++;

    //set adjAdj's checkAdjDomV to true
    for (unsigned k = 0, dadj = dVDegree[adj]; k < dadj; k++) {
        unsigned adjAdj = vAdj[adj][k];
        checkAdjDomV[adjAdj] = IN;
    }

    //remove adj's neighbours from adj
    dVDegree[adj] = 0;
    return true;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq 0x4511(%rip), %rax      # 0xb180
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl (%rax), %eax
movl %eax, 0x10(%rsp)
movq 0x4524(%rip), %rax      # 0xb1a8
movl 0x10(%rsp), %ecx
movb $0x4, (%rax,%rcx)
movl 0x4562(%rip), %eax      # 0xb1f4
addl $0x1, %eax
movl %eax, 0x4559(%rip)      # 0xb1f4
movl 0x10(%rsp), %edi
callq 0x2c50
movq 0x44fd(%rip), %rax      # 0xb1a8
movl 0x14(%rsp), %ecx
movb $0x1, (%rax,%rcx)
movl 0x4567(%rip), %eax      # 0xb220
addl $0x1, %eax
movl %eax, 0x455e(%rip)      # 0xb220
movl $0x0, 0xc(%rsp)
movq 0x44df(%rip), %rax      # 0xb1b0
movl 0x10(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
jae 0x6d1c
movq 0x4493(%rip), %rax      # 0xb180
movl 0x10(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl 0xc(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, 0x4(%rsp)
movq 0x44d1(%rip), %rax      # 0xb1d8
movl 0x4(%rsp), %ecx
movb $0x3, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x6cdc
movq 0x448d(%rip), %rax      # 0xb1b0
movl 0x10(%rsp), %ecx
movl $0x0, (%rax,%rcx,4)
movb $0x1, %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: quancs[P]EAVC/./eavc.h
// Function: update_best_sol()
inline void update_best_sol() {
    memcpy(vInBest, vInC, sizeof(VerticeStatus)*vNum);

    bestSize = total_IN_ABS + cvSize;
#ifdef WIN32
    finish = clock();
    bestTime = (static_cast<double>(finish - gstart));
#else
    times(&finish);
    bestTime = double(finish.tms_utime + finish.tms_stime - startTime);
#endif
    bestStep = step;
    //cout << "c Best vertex cover size = " << best_c_size <<  ", SearchSteps = " << best_step <<  ", SearchTime = " << best_comp_time << endl;
}

// Assembly:
pushq %rax
movq 0x3f60(%rip), %rdi      # 0xb1a8
movq 0x3f41(%rip), %rsi      # 0xb190
movl 0x3ee7(%rip), %eax      # 0xb13c
movl %eax, %edx
shlq $0x0, %rdx
callq 0x2100
movl 0x3f8e(%rip), %eax      # 0xb1f4
addl 0x3f84(%rip), %eax      # 0xb1f0
movl %eax, 0x3f86(%rip)      # 0xb1f8
leaq 0x3f87(%rip), %rdi      # 0xb200
callq 0x21b0
movq 0x3f7b(%rip), %rax      # 0xb200
addq 0x3f7c(%rip), %rax      # 0xb208
movslq 0x3fa5(%rip), %rcx      # 0xb238
subq %rcx, %rax
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x3fcd(%rip)     # 0xb270
movl 0x3f8b(%rip), %eax      # 0xb234
movl %eax, 0x3fc9(%rip)      # 0xb278
popq %rax
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: quancs[P]EAVC/./eavc.h
// Function: in(VerticeStatus*, unsigned int)
inline bool in(VerticeStatus *vs, unsigned v) {
    if (vs[v] > UNKNOWN) { // vs[v] == IN || vs[v] == IN_ABS
        return true;
    } else {
        return false;
    }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
movzbl (%rax,%rcx), %eax
cmpl $0x2, %eax
jle 0x72e2
movb $0x1, -0x1(%rsp)
jmp 0x72e7
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nop
// File: quancs[P]EAVC/./eavc.h
// Function: not_in(VerticeStatus*, unsigned int)
inline bool not_in(VerticeStatus *vs, unsigned v) {
    if (vs[v] < UNKNOWN) { //vs[v] == NIN || vs[v] == NIN_ABS
        return true;
    } else {
        return false;
    }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
movzbl (%rax,%rcx), %eax
cmpl $0x2, %eax
jge 0x7312
movb $0x1, -0x1(%rsp)
jmp 0x7317
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nop
// File: quancs[P]EAVC/./eavc.h
// Function: cover(unsigned int)
inline
void cover(unsigned int e) {
    unsigned int index, last_uncov_edge;

    //since the edge is satisfied, its position can be reused to store the last_uncov_edge
    last_uncov_edge = uncovEdges[--ueSize];
    index = uncovEdgeIndexes[e];
    uncovEdges[index] = last_uncov_edge;
    uncovEdgeIndexes[last_uncov_edge] = index;
}

// Assembly:
movl %edi, -0x4(%rsp)
movq 0x3e2d(%rip), %rax      # 0xb158
movl 0x3ebb(%rip), %ecx      # 0xb1ec
addl $-0x1, %ecx
movl %ecx, 0x3eb2(%rip)      # 0xb1ec
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rsp)
movq 0x3e16(%rip), %rax      # 0xb160
movl -0x4(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rsp)
movl -0xc(%rsp), %edx
movq 0x3df8(%rip), %rax      # 0xb158
movl -0x8(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x8(%rsp), %edx
movq 0x3dee(%rip), %rax      # 0xb160
movl -0xc(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
retq
nopw (%rax,%rax)
// File: jkom-cloud[P]mmseg/src/Mmseg.cpp
// Function: mmsegSpace::MMSeg::unload()
void mmsegSpace::MMSeg::unload() {
    mtx.lock();
    dict_.clear();
    is_inited = false;
    mtx.unlock();
  }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x8, %rdi
callq 0x54f0
movq 0x8(%rsp), %rdi
addq $0x68, %rdi
callq 0x5da0
movq 0x8(%rsp), %rdi
movb $0x0, (%rdi)
addq $0x8, %rdi
callq 0x5520
addq $0x18, %rsp
retq
// File: jkom-cloud[P]mmseg/src/Mmseg.cpp
// Function: mmsegSpace::MMSeg::getInitStatus()
bool mmsegSpace::MMSeg::getInitStatus() {
    bool status = false;
    mtx.lock();
    status = is_inited;
    mtx.unlock();
    return status;
  }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movb $0x0, 0xf(%rsp)
addq $0x8, %rdi
callq 0x54f0
movq (%rsp), %rdi
movb (%rdi), %al
andb $0x1, %al
movb %al, 0xf(%rsp)
addq $0x8, %rdi
callq 0x5520
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
// File: jkom-cloud[P]mmseg/src/TransCode.hpp
// Function: TransCode::from_utf8(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline static std::u16string from_utf8(const std::string& in) {
	std::u16string out;
#ifdef MMSEG_GBK
	gbkTrans(in, out);
#else
	utf8ToUnicode(in, out);
#endif
	return out;
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movb $0x0, 0x27(%rsp)
callq 0x60c0
movq 0x8(%rsp), %rsi
movq 0x28(%rsp), %rdi
callq 0x6140
jmp 0x5565
movb $0x1, 0x27(%rsp)
testb $0x1, 0x27(%rsp)
jne 0x5597
jmp 0x558d
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x5900
jmp 0x55a0
movq 0x8(%rsp), %rdi
callq 0x5900
movq (%rsp), %rax
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x3470
nopw (%rax,%rax)
// File: jkom-cloud[P]mmseg/src/TransCode.hpp
// Function: TransCode::to_utf8(std::__cxx11::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>> const&)
inline static std::string to_utf8(const std::u16string& in) {
    std::string out;
#ifdef MMSEG_GBK
	gbkTrans(in.begin(), in.end(), out);
#else
	unicodeToUtf8(in.begin(), in.end(), out);
#endif
	return out;
  }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movb $0x0, 0x37(%rsp)
callq 0x3370
movq 0x38(%rsp), %rdi
callq 0x6e00
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x6e30
movq 0x8(%rsp), %rdx
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x6ce0
jmp 0x5a58
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0x5a8a
jmp 0x5a80
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x3160
jmp 0x5a93
movq 0x8(%rsp), %rdi
callq 0x3160
movq (%rsp), %rax
addq $0x48, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x3470
nopl (%rax)
// File: jkom-cloud[P]mmseg/src/Trie.hpp
// Function: mmsegSpace::Trie::add(std::__cxx11::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>> const&)
void add(const String& word) {
			Node *current = &root_;
			for (auto ch: word) {
				auto it = current->trans_.find(ch);
				if (it == current->trans_.end()) {
					auto ret = current->trans_.emplace(ch, new Node{});
                                        //std::cout << "Current: " << current << " Alloc:" << ret.first->second << std::endl;
					current = ret.first->second;
				}
				else {
					current = it->second;
				}
			}
			current->val_ = true;// 词条存在
		}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdi
callq 0x6e00
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rdi
callq 0x6e30
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x6e90
testb $0x1, %al
jne 0x5ba1
jmp 0x5c8b
leaq 0x60(%rsp), %rdi
callq 0x6ed0
movw (%rax), %ax
movw %ax, 0x56(%rsp)
movq 0x70(%rsp), %rdi
leaq 0x56(%rsp), %rsi
callq 0x7b10
movq %rax, 0x48(%rsp)
movq 0x70(%rsp), %rdi
callq 0x7b60
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x7b40
testb $0x1, %al
jne 0x5beb
jmp 0x5c67
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x40, %edi
callq 0x32b0
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovdqu64 %zmm0, (%rdi)
vzeroupper
callq 0x7be0
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdi
movq %rax, 0x28(%rsp)
leaq 0x56(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x7b90
movb %dl, 0x20(%rsp)
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movb 0x20(%rsp), %al
movb %al, 0x38(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x7c10
movq 0x8(%rax), %rax
movq %rax, 0x70(%rsp)
jmp 0x5c7a
leaq 0x48(%rsp), %rdi
callq 0x7c10
movq 0x8(%rax), %rax
movq %rax, 0x70(%rsp)
jmp 0x5c7c
leaq 0x60(%rsp), %rdi
callq 0x7c30
jmp 0x5b89
movq 0x70(%rsp), %rax
movb $0x1, 0x38(%rax)
addq $0x88, %rsp
retq
nopl (%rax)
// File: jkom-cloud[P]mmseg/src/Trie.hpp
// Function: mmsegSpace::Trie::clear()
void clear() {
                         Node *r = &root_;
                         for (auto a = r->trans_.begin(); a != r->trans_.end();a++)
                           clear_(a->second);
                         r->trans_.clear();
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x9520
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x7b60
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x9550
testb $0x1, %al
jne 0x5deb
jmp 0x5e16
leaq 0x20(%rsp), %rdi
callq 0x7c10
movq 0x8(%rsp), %rdi
movq 0x8(%rax), %rsi
callq 0x9570
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x9610
movq %rax, 0x10(%rsp)
jmp 0x5dc7
movq 0x28(%rsp), %rdi
callq 0x9640
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: jkom-cloud[P]mmseg/src/util/StringUtil.hpp
// Function: void utilSpace::unicodeToUtf8<__gnu_cxx::__normal_iterator<char16_t const*, std::__cxx11::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>>>(__gnu_cxx::__normal_iterator<char16_t const*, std::__cxx11::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>>, __gnu_cxx::__normal_iterator<char16_t const*, std::__cxx11::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void unicodeToUtf8(Uint16ContainerConIter begin, Uint16ContainerConIter end, string& res) {
  res.clear();
  uint16_t ui;
  while(begin != end) {
    ui = *begin;
    if(ui <= 0x7f) {
      res += char(ui);
    } else if(ui <= 0x7ff) {
      res += char(((ui>>6) & 0x1f) | 0xc0);
      res += char((ui & 0x3f) | 0x80);
    } else {
      res += char(((ui >> 12) & 0x0f )| 0xe0);
      res += char(((ui>>6) & 0x3f )| 0x80 );
      res += char((ui & 0x3f) | 0x80);
    }
    begin ++;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x3340
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x6e90
testb $0x1, %al
jne 0x6d15
jmp 0x6df8
leaq 0x20(%rsp), %rdi
callq 0x6ed0
movw (%rax), %ax
movw %ax, 0xe(%rsp)
movzwl 0xe(%rsp), %eax
cmpl $0x7f, %eax
jg 0x6d48
movw 0xe(%rsp), %ax
movq 0x10(%rsp), %rdi
movsbl %al, %esi
callq 0x3170
jmp 0x6de3
movzwl 0xe(%rsp), %eax
cmpl $0x7ff, %eax            # imm = 0x7FF
jg 0x6d8d
movzwl 0xe(%rsp), %eax
sarl $0x6, %eax
andl $0x1f, %eax
orl $0xc0, %eax
movq 0x10(%rsp), %rdi
movsbl %al, %esi
callq 0x3170
movzwl 0xe(%rsp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movq 0x10(%rsp), %rdi
movsbl %al, %esi
callq 0x3170
jmp 0x6de1
movzwl 0xe(%rsp), %eax
sarl $0xc, %eax
andl $0xf, %eax
orl $0xe0, %eax
movq 0x10(%rsp), %rdi
movsbl %al, %esi
callq 0x3170
movzwl 0xe(%rsp), %eax
sarl $0x6, %eax
andl $0x3f, %eax
orl $0x80, %eax
movq 0x10(%rsp), %rdi
movsbl %al, %esi
callq 0x3170
movzwl 0xe(%rsp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movq 0x10(%rsp), %rdi
movsbl %al, %esi
callq 0x3170
jmp 0x6de3
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x6ee0
movq %rax, (%rsp)
jmp 0x6cfd
addq $0x28, %rsp
retq
nopl (%rax)
// File: jkom-cloud[P]mmseg/src/Trie.hpp
// Function: mmsegSpace::Trie::clear_(mmsegSpace::Trie::Node*)
void clear_(Node * pNode) {
                         for (auto a = pNode->trans_.begin(); a != pNode->trans_.end();a++) {
                           clear_(a->second);
                         }
                         //std::cout<<"Free : "<<pNode<<std::endl;
                         delete pNode;
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x9520
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x7b60
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x9550
testb $0x1, %al
jne 0x95bb
jmp 0x95e6
leaq 0x20(%rsp), %rdi
callq 0x7c10
movq 0x8(%rsp), %rdi
movq 0x8(%rax), %rsi
callq 0x9570
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x9610
movq %rax, 0x10(%rsp)
jmp 0x9597
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x9607
movq (%rsp), %rdi
callq 0x9680
movq (%rsp), %rdi
callq 0x3270
addq $0x38, %rsp
retq
nopl (%rax)
// File: jkom-cloud[P]mmseg/src/Trie.hpp
// Function: mmsegSpace::Trie::match_all(__gnu_cxx::__normal_iterator<char16_t const*, std::__cxx11::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>>, __gnu_cxx::__normal_iterator<char16_t const*, std::__cxx11::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>>)
std::vector<StringP> match_all(StringIt start, StringIt end) {
			std::vector<StringP> ret;
			Node *current = &root_;
			StringIt _start = start;
			for (; start != end; ++start) {
				auto ch = *start;
				auto it = current->trans_.find(ch);
				if (it == current->trans_.end())
					break;
				current = it->second;
				if (current->val_) {
                                  ret.emplace_back(_start, start + 1);
                                }
			}
			return ret;
		}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
movb $0x0, 0x67(%rsp)
callq 0x5390
movq 0x18(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x6e90
testb $0x1, %al
jne 0xa18b
jmp 0xa256
leaq 0x78(%rsp), %rdi
callq 0x6ed0
movw (%rax), %ax
movw %ax, 0x4e(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x4e(%rsp), %rsi
callq 0x7b10
movq %rax, (%rsp)
jmp 0xa1b2
movq (%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rdi
callq 0x7b60
movq %rax, 0x28(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x7b40
testb $0x1, %al
jne 0xa1df
jmp 0xa1fb
jmp 0xa256
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x5410
jmp 0xa279
leaq 0x40(%rsp), %rdi
callq 0x7c10
movq 0x8(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
testb $0x1, 0x38(%rax)
je 0xa245
leaq 0x78(%rsp), %rdi
movl $0x1, %esi
callq 0xa620
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
leaq 0x50(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0xa680
jmp 0xa243
jmp 0xa245
jmp 0xa247
leaq 0x78(%rsp), %rdi
callq 0x7c30
jmp 0xa173
movb $0x1, 0x67(%rsp)
testb $0x1, 0x67(%rsp)
jne 0xa26c
movq 0x8(%rsp), %rdi
callq 0x5410
movq 0x10(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x3470
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jkom-cloud[P]mmseg/src/MmsegWrapper.cpp
// Function: copySegs
char * copySegs(struct tagMMSeg * pInstance, const char * pOrigStr) {
  std::string istr(pOrigStr); 
  std::string ostr;

  ostr = pInstance->ptr_mmseg->segment(istr);
  char * out = new char[ostr.length() + 1];

  strcpy(out, ostr.c_str());

  return out;
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x97(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x3480
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
leaq 0x98(%rsp), %rdi
callq 0x3360
jmp 0xf93f
leaq 0x97(%rsp), %rdi
callq 0x32e0
leaq 0x60(%rsp), %rdi
callq 0x3370
movq 0xc0(%rsp), %rax
movq (%rax), %rsi
leaq 0x40(%rsp), %rdi
leaq 0x98(%rsp), %rdx
movl $0x3, %ecx
callq 0x3940
jmp 0xf97a
leaq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
leaq 0x40(%rsp), %rsi
movq %rsi, 0x10(%rsp)
callq 0x3300
movq 0x10(%rsp), %rdi
callq 0x3160
movq 0x18(%rsp), %rdi
callq 0x33c0
movq %rax, %rdi
incq %rdi
callq 0x3030
movq %rax, 0x20(%rsp)
jmp 0xf9b9
movq 0x20(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
leaq 0x60(%rsp), %rdi
callq 0x30f0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x3260
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x3160
leaq 0x98(%rsp), %rdi
callq 0x3160
movq 0x8(%rsp), %rax
addq $0xc8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x97(%rsp), %rdi
callq 0x32e0
jmp 0xfa5e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x3160
leaq 0x98(%rsp), %rdi
callq 0x3160
movq 0x88(%rsp), %rdi
callq 0x3470
nopl (%rax,%rax)
// File: lluchs[P]sparsearray/main.cpp
// Function: void run_benchmark<BitmapSA<C4PXS, 10000ul>>(char const*)
static void run_benchmark(const char *name)
{
	std::chrono::time_point<std::chrono::high_resolution_clock> start, end;
	std::chrono::duration<double> elapsed_seconds;

	std::cout << "start " << name << std::endl;
	start = std::chrono::high_resolution_clock::now();
	auto r = benchmark<SparseArray>(iterations, seed, addmod);
	end = std::chrono::high_resolution_clock::now();
	elapsed_seconds = end - start;
	std::cout << "end = " << std::chrono::duration_cast<std::chrono::microseconds>(elapsed_seconds).count() << " μs" << std::endl;
	std::cout << "static size = " << sizeof(SparseArray) << " byte" << std::endl;
	std::cout << "count = " << r.count << std::endl;
	std::cout << "sum = " << r.sum << std::endl << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3a50
leaq -0x18(%rbp), %rdi
callq 0x3a50
movq 0xa8fb(%rip), %rdi      # 0xcfd0
leaq 0x69df(%rip), %rsi      # 0x90bb
callq 0x2120
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x2120
movq %rax, %rdi
movq 0xa8c1(%rip), %rsi      # 0xcfb8
callq 0x2130
callq 0x2040
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movl 0xaa15(%rip), %edi      # 0xd128
movq 0xaa16(%rip), %rsi      # 0xd130
movl 0xaa18(%rip), %edx      # 0xd138
callq 0x3a80
movq %rax, -0x30(%rbp)
callq 0x2040
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x3db0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3e00
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0xa869(%rip), %rdi      # 0xcfd0
leaq 0x6954(%rip), %rsi      # 0x90c2
callq 0x2120
movq %rax, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3e40
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3e70
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x2200
movq %rax, %rdi
leaq 0x6926(%rip), %rsi      # 0x90c9
callq 0x2120
movq %rax, %rdi
movq 0xa806(%rip), %rsi      # 0xcfb8
callq 0x2130
movq 0xa812(%rip), %rdi      # 0xcfd0
leaq 0x6909(%rip), %rsi      # 0x90ce
callq 0x2120
movq %rax, %rdi
movl $0x31228, %esi          # imm = 0x31228
callq 0x2070
movq %rax, %rdi
leaq 0x687d(%rip), %rsi      # 0x905e
callq 0x2120
movq %rax, %rdi
movq 0xa7c8(%rip), %rsi      # 0xcfb8
callq 0x2130
movq 0xa7d4(%rip), %rdi      # 0xcfd0
leaq 0x68da(%rip), %rsi      # 0x90dd
callq 0x2120
movq %rax, %rdi
movl -0x30(%rbp), %esi
callq 0x21d0
movq %rax, %rdi
movq 0xa79b(%rip), %rsi      # 0xcfb8
callq 0x2130
movq 0xa7a7(%rip), %rdi      # 0xcfd0
leaq 0x68b6(%rip), %rsi      # 0x90e6
callq 0x2120
movq %rax, %rdi
movl -0x2c(%rbp), %esi
callq 0x21d0
movq %rax, %rdi
movq 0xa76e(%rip), %rsi      # 0xcfb8
callq 0x2130
movq %rax, %rdi
movq 0xa75f(%rip), %rsi      # 0xcfb8
callq 0x2130
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lluchs[P]sparsearray/./sparsearray.h
// Function: BitmapSA<C4PXS, 10000ul>::New()
T* New()
	{
		for (size_t i = 0; i < maskN; i++)
		{
			uint64_t m = ~mask[i];
			if (m)
			{
				size_t j = __builtin_ffsll(m) - 1;
				size_t idx = i*64 + j;
				if (idx >= N) return nullptr;
				mask[i] |= (uint64_t) 1 << j;
				return &data[idx];
			}
		}
		return nullptr;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x9d, -0x18(%rbp)
jae 0x407e
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x30d40(%rax,%rcx,8), %rax
xorq $-0x1, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x406b
movq -0x20(%rbp), %rdx
tzcntq %rdx, %rax
addq $0x1, %rax
xorl %ecx, %ecx
cmpq $0x0, %rdx
cmoveq %rcx, %rax
subl $0x1, %eax
cltq
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
shlq $0x6, %rax
addq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x2710, -0x30(%rbp)    # imm = 0x2710
jb 0x4039
movq $0x0, -0x8(%rbp)
jmp 0x4086
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq -0x18(%rbp), %rcx
orq 0x30d40(%rax,%rcx,8), %rdx
movq %rdx, 0x30d40(%rax,%rcx,8)
imulq $0x14, -0x30(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x4086
jmp 0x406d
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3fc8
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: lluchs[P]sparsearray/./sparsearray.h
// Function: BitmapSA<C4PXS, 10000ul>::Delete(C4PXS*)
void Delete(T *el)
	{
		size_t idx = el - data;
		assert(idx < N);
		size_t i = idx / 64, j = idx % 64;
		mask[i] &= ~((uint64_t) 1 << j);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq -0x10(%rbp), %rax
subq %rcx, %rax
movl $0x14, %ecx
cqto
idivq %rcx
movq %rax, -0x18(%rbp)
cmpq $0x2710, -0x18(%rbp)    # imm = 0x2710
jae 0x4229
jmp 0x4248
leaq 0x4f53(%rip), %rdi      # 0x9183
leaq 0x4ebd(%rip), %rsi      # 0x90f4
movl $0x21, %edx
leaq 0x4f48(%rip), %rcx      # 0x918b
callq 0x20c0
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
shrq $0x6, %rcx
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rcx
andq $0x3f, %rcx
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movl $0x1, %edx
shlq %cl, %rdx
xorq $-0x1, %rdx
movq -0x20(%rbp), %rcx
andq 0x30d40(%rax,%rcx,8), %rdx
movq %rdx, 0x30d40(%rax,%rcx,8)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: lluchs[P]sparsearray/./sparsearray.h
// Function: BitmapSA<C4PXS, 10000ul>::Iterator<C4PXS, BitmapSA<C4PXS, 10000ul>>::operator++()
Iterator& operator++()
		{
			assert(array);
			while (!cur)
			{
				el += 64 - pos;
				if (el >= N) break;
				pos = 0;
				cur = array->mask[(el + 1) / 64];
			}
			size_t inc = __builtin_ffsll(cur);
			el += inc - start;
			pos += inc;
			cur >>= inc;
			if (el >= N)
			{
				array = nullptr;
				el = 0;
			}
			return *this;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, (%rax)
je 0x42ac
jmp 0x42cb
leaq 0x4f18(%rip), %rdi      # 0x91cb
leaq 0x4e3a(%rip), %rsi      # 0x90f4
movl $0x37, %edx
leaq 0x4f0b(%rip), %rcx      # 0x91d1
callq 0x20c0
jmp 0x42cd
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x42e1
jmp 0x432b
movq -0x18(%rbp), %rax
movl $0x40, %ecx
subq 0x10(%rax), %rcx
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x2710, 0x8(%rax)      # imm = 0x2710
jb 0x4302
jmp 0x432b
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq (%rax), %rcx
movq 0x8(%rax), %rdx
addq $0x1, %rdx
shrq $0x6, %rdx
movq 0x30d40(%rcx,%rdx,8), %rcx
movq %rcx, 0x20(%rax)
jmp 0x42cd
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
tzcntq %rsi, %rcx
addq $0x1, %rcx
xorl %edx, %edx
cmpq $0x0, %rsi
cmoveq %rdx, %rcx
movslq %ecx, %rcx
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
subq 0x18(%rax), %rcx
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq 0x20(%rax), %rdx
shrq %cl, %rdx
movq %rdx, %rcx
movq %rcx, 0x20(%rax)
cmpq $0x2710, 0x8(%rax)      # imm = 0x2710
jb 0x4398
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: lluchs[P]sparsearray/./sparsearray.h
// Function: BitmapSA<C4PXS, 10000ul>::Iterator<C4PXS, BitmapSA<C4PXS, 10000ul>>::Iterator(BitmapSA<C4PXS, 10000ul>*)
Iterator(SA *array) : array(array), el(0), pos(64), cur(0)
		{
			start = 1;
			if (array)
				operator++();
			start = 0;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movq $0x40, 0x10(%rax)
movq $0x0, 0x20(%rax)
movq $0x1, 0x18(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x442f
movq -0x18(%rbp), %rdi
callq 0x4290
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: lluchs[P]sparsearray/./sparsearray.h
// Function: ChunkSA<C4PXS, 10000ul, 500ul>::New()
T* New()
	{
		for (size_t i = 0; i < MaxChunk; i++)
		{
			// Create new chunk if necessary.
			if (!Chunk[i])
			{
				Chunk[i] = new T[ChunkSize];
				ChunkFill[i] = 0;
			}
			// Check this chunk for space.
			if (ChunkFill[i] < ChunkSize)
				for (size_t j = 0; j < ChunkSize; j++)
					if (!UsedElements[i*ChunkSize + j])
					{
						UsedElements.set(i*ChunkSize + j);
						ChunkFill[i]++;
						return &Chunk[i][j];
					}
		}
		return nullptr;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x14, -0x18(%rbp)
jae 0x4c8a
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x4b9f
movl $0x2710, %edi           # imm = 0x2710
callq 0x2030
movq %rax, -0x60(%rbp)
movq %rax, %rcx
addq $0x2710, %rcx           # imm = 0x2710
movq %rcx, -0x58(%rbp)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x43b0
jmp 0x4b49
movq -0x58(%rbp), %rcx
movq -0x68(%rbp), %rax
addq $0x14, %rax
cmpq %rcx, %rax
movq %rax, -0x50(%rbp)
jne 0x4b3a
movq -0x48(%rbp), %rax
movq -0x60(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rcx
movq $0x0, 0xa0(%rax,%rcx,8)
jmp 0x4b9f
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x2710, %esi           # imm = 0x2710
callq 0x2210
jmp 0x4c9c
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq $0x1f4, 0xa0(%rax,%rcx,8) # imm = 0x1F4
jae 0x4c77
movq $0x0, -0x30(%rbp)
cmpq $0x1f4, -0x30(%rbp)     # imm = 0x1F4
jae 0x4c75
movq -0x48(%rbp), %rsi
addq $0x140, %rsi            # imm = 0x140
imulq $0x1f4, -0x18(%rbp), %rdx # imm = 0x1F4
addq -0x30(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x5070
leaq -0x40(%rbp), %rdi
callq 0x50b0
xorb $-0x1, %al
movb %al, -0x69(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x50f0
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x4c0f
jmp 0x4c62
movq -0x48(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
imulq $0x1f4, -0x18(%rbp), %rsi # imm = 0x1F4
addq -0x30(%rbp), %rsi
movl $0x1, %edx
callq 0x5100
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0xa0(%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, 0xa0(%rax,%rcx,8)
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
imulq $0x14, -0x30(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x4c92
jmp 0x4c64
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x4bc1
jmp 0x4c77
jmp 0x4c79
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4afc
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x21e0
nopw %cs:(%rax,%rax)
nop
// File: lluchs[P]sparsearray/./sparsearray.h
// Function: ChunkSA<C4PXS, 10000ul, 500ul>::Delete(C4PXS*)
void Delete(T *el)
	{
		size_t i, j;
		for (i = 0; i < MaxChunk; i++)
			if (ChunkFill[i])
				if (el >= &Chunk[i][0] && el < &Chunk[i][ChunkSize])
					break;
		assert(i < MaxChunk);

		j = el - &Chunk[i][0];
		assert(UsedElements[i*ChunkSize + j]);
		UsedElements.reset(i*ChunkSize + j);

		if (--ChunkFill[i] == 0)
		{
			delete[] Chunk[i];
			Chunk[i] = nullptr;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x14, -0x18(%rbp)
jae 0x4e5f
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq $0x0, 0xa0(%rax,%rcx,8)
je 0x4e4f
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq %rcx, %rax
jb 0x4e4d
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
addq $0x2710, %rcx           # imm = 0x2710
cmpq %rcx, %rax
jae 0x4e4d
jmp 0x4e5f
jmp 0x4e4f
jmp 0x4e51
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4e00
cmpq $0x14, -0x18(%rbp)
jae 0x4e68
jmp 0x4e87
leaq 0x442a(%rip), %rdi      # 0x9299
leaq 0x427e(%rip), %rsi      # 0x90f4
movl $0x92, %edx
leaq 0x4424(%rip), %rcx      # 0x92a6
callq 0x20c0
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rsi,%rcx,8), %rcx
subq %rcx, %rax
movl $0x14, %ecx
cqto
idivq %rcx
movq %rax, -0x20(%rbp)
addq $0x140, %rsi            # imm = 0x140
imulq $0x1f4, -0x18(%rbp), %rdx # imm = 0x1F4
addq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x5070
leaq -0x30(%rbp), %rdi
callq 0x50b0
testb $0x1, %al
jne 0x4ed3
jmp 0x4ed5
jmp 0x4ef4
leaq 0x441a(%rip), %rdi      # 0x92f6
leaq 0x4211(%rip), %rsi      # 0x90f4
movl $0x95, %edx
leaq 0x43b7(%rip), %rcx      # 0x92a6
callq 0x20c0
leaq -0x30(%rbp), %rdi
callq 0x50f0
movq -0x38(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
imulq $0x1f4, -0x18(%rbp), %rsi # imm = 0x1F4
addq -0x20(%rbp), %rsi
callq 0x54e0
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rdx
movq 0xa0(%rcx,%rdx,8), %rax
addq $-0x1, %rax
movq %rax, 0xa0(%rcx,%rdx,8)
cmpq $0x0, %rax
jne 0x4f6a
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x4f5a
movq -0x40(%rbp), %rdi
callq 0x2180
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
addq $0x40, %rsp
popq %rbp
retq
// File: lluchs[P]sparsearray/./sparsearray.h
// Function: ChunkSA<C4PXS, 10000ul, 500ul>::~ChunkSA()
~ChunkSA()
	{
		for (size_t i = 0; i < MaxChunk; i++)
		{
			if (Chunk[i]) delete[] Chunk[i];
			Chunk[i] = nullptr;
			ChunkFill[i] = 0;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x14, -0x10(%rbp)
jae 0x5011
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x4fe3
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x4fe1
movq -0x20(%rbp), %rdi
callq 0x2180
jmp 0x4fe3
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x10(%rbp), %rcx
movq $0x0, 0xa0(%rax,%rcx,8)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4fac
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lluchs[P]sparsearray/./sparsearray.h
// Function: ChunkSA<C4PXS, 10000ul, 500ul>::Iterator<C4PXS, ChunkSA<C4PXS, 10000ul, 500ul>>::next(bool)
Iterator& next(bool return_next)
		{
			for (; i < MaxChunk; i++, j = 0)
			{
				if (array->ChunkFill[i])
				{
					for (; j < ChunkSize; j++)
					{
						if (array->UsedElements[i*ChunkSize + j] && return_next)
							return *this;
						return_next = true;
					}
				}
				return_next = true;
			}
			// We're at the end.
			array = nullptr;
			i = j = 0;
			return *this;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x14, 0x8(%rax)
jae 0x5453
movq -0x30(%rbp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
cmpq $0x0, 0xa0(%rax,%rcx,8)
je 0x5432
jmp 0x53a7
movq -0x30(%rbp), %rax
cmpq $0x1f4, 0x10(%rax)      # imm = 0x1F4
jae 0x5430
movq -0x30(%rbp), %rax
movq (%rax), %rsi
addq $0x140, %rsi            # imm = 0x140
imulq $0x1f4, 0x8(%rax), %rdx # imm = 0x1F4
addq 0x10(%rax), %rdx
leaq -0x28(%rbp), %rdi
callq 0x5070
leaq -0x28(%rbp), %rdi
callq 0x50b0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x31(%rbp)
jne 0x53ef
jmp 0x53f5
movb -0x11(%rbp), %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
movb %al, -0x32(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x50f0
movb -0x32(%rbp), %al
testb $0x1, %al
jne 0x540d
jmp 0x5417
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5472
movb $0x1, -0x11(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0x53a7
jmp 0x5432
movb $0x1, -0x11(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq $0x0, 0x10(%rax)
jmp 0x537c
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x8(%rax)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: lluchs[P]sparsearray/./sparsearray.h
// Function: StaticChunkSA<C4PXS, 10000ul, 500ul>::New()
T* New()
	{
		for (size_t i = 0; i < MaxChunk; i++)
		{
			// Check this chunk for space.
			if (ChunkFill[i] < ChunkSize)
				for (size_t j = 0; j < ChunkSize; j++)
					if (!UsedElements[i*ChunkSize + j])
					{
						UsedElements.set(i*ChunkSize + j);
						ChunkFill[i]++;
						return &Chunk[i][j];
					}
		}
		return nullptr;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x14, -0x18(%rbp)
jae 0x5a65
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq $0x1f4, 0x30d40(%rax,%rcx,8) # imm = 0x1F4
jae 0x5a52
movq $0x0, -0x20(%rbp)
cmpq $0x1f4, -0x20(%rbp)     # imm = 0x1F4
jae 0x5a50
movq -0x38(%rbp), %rsi
addq $0x30de0, %rsi          # imm = 0x30DE0
imulq $0x1f4, -0x18(%rbp), %rdx # imm = 0x1F4
addq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x5070
leaq -0x30(%rbp), %rdi
callq 0x50b0
xorb $-0x1, %al
movb %al, -0x39(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x50f0
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x59e7
jmp 0x5a3d
movq -0x38(%rbp), %rdi
addq $0x30de0, %rdi          # imm = 0x30DE0
imulq $0x1f4, -0x18(%rbp), %rsi # imm = 0x1F4
addq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0x5100
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x30d40(%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, 0x30d40(%rax,%rcx,8)
imulq $0x2710, -0x18(%rbp), %rcx # imm = 0x2710
addq %rcx, %rax
imulq $0x14, -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x5a6d
jmp 0x5a3f
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5999
jmp 0x5a52
jmp 0x5a54
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x596c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lluchs[P]sparsearray/./sparsearray.h
// Function: StaticChunkSA<C4PXS, 10000ul, 500ul>::Delete(C4PXS*)
void Delete(T *el)
	{
		size_t i, j;
		for (i = 0; i < MaxChunk; i++)
			if (ChunkFill[i])
				if (el >= &Chunk[i][0] && el < &Chunk[i][ChunkSize])
					break;
		assert(i < MaxChunk);

		j = el - &Chunk[i][0];
		assert(UsedElements[i*ChunkSize + j]);
		UsedElements.reset(i*ChunkSize + j);

		--ChunkFill[i];
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x14, -0x18(%rbp)
jae 0x5c35
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq $0x0, 0x30d40(%rax,%rcx,8)
je 0x5c25
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
imulq $0x2710, -0x18(%rbp), %rdx # imm = 0x2710
addq %rdx, %rcx
cmpq %rcx, %rax
jb 0x5c23
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
imulq $0x2710, -0x18(%rbp), %rdx # imm = 0x2710
addq %rdx, %rcx
addq $0x2710, %rcx           # imm = 0x2710
cmpq %rcx, %rax
jae 0x5c23
jmp 0x5c35
jmp 0x5c25
jmp 0x5c27
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x5bd0
cmpq $0x14, -0x18(%rbp)
jae 0x5c3e
jmp 0x5c5d
leaq 0x3654(%rip), %rdi      # 0x9299
leaq 0x34a8(%rip), %rsi      # 0x90f4
movl $0xfb, %edx
leaq 0x36ca(%rip), %rcx      # 0x9322
callq 0x20c0
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rax
imulq $0x2710, -0x18(%rbp), %rdx # imm = 0x2710
movq %rsi, %rcx
addq %rdx, %rcx
subq %rcx, %rax
movl $0x14, %ecx
cqto
idivq %rcx
movq %rax, -0x20(%rbp)
addq $0x30de0, %rsi          # imm = 0x30DE0
imulq $0x1f4, -0x18(%rbp), %rdx # imm = 0x1F4
addq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x5070
leaq -0x30(%rbp), %rdi
callq 0x50b0
testb $0x1, %al
jne 0x5caf
jmp 0x5cb1
jmp 0x5cd0
leaq 0x363e(%rip), %rdi      # 0x92f6
leaq 0x3435(%rip), %rsi      # 0x90f4
movl $0xfe, %edx
leaq 0x3657(%rip), %rcx      # 0x9322
callq 0x20c0
leaq -0x30(%rbp), %rdi
callq 0x50f0
movq -0x38(%rbp), %rdi
addq $0x30de0, %rdi          # imm = 0x30DE0
imulq $0x1f4, -0x18(%rbp), %rsi # imm = 0x1F4
addq -0x20(%rbp), %rsi
callq 0x54e0
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x30d40(%rax,%rcx,8), %rdx
addq $-0x1, %rdx
movq %rdx, 0x30d40(%rax,%rcx,8)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lluchs[P]sparsearray/./sparsearray.h
// Function: LinkedListSA<C4PXS, 10000ul>::LinkedListSA()
LinkedListSA() : firstUsed(nullptr), firstFree(array)
	{
		// Everything starts in the free list.
		for (size_t i = 1; i < N; i++)
			array[i-1].next = &array[i];
		array[N-1].next = nullptr;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rax, %rcx
addq $0x61a80, %rcx          # imm = 0x61A80
movq %rcx, -0x20(%rbp)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x6720
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
addq $0x28, %rax
cmpq %rcx, %rax
movq %rax, -0x18(%rbp)
jne 0x6266
movq -0x28(%rbp), %rax
movq $0x0, 0x61a80(%rax)
movq %rax, 0x61a88(%rax)
movq $0x1, -0x10(%rbp)
cmpq $0x2710, -0x10(%rbp)    # imm = 0x2710
jae 0x62e0
movq -0x28(%rbp), %rax
imulq $0x28, -0x10(%rbp), %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq -0x10(%rbp), %rdx
subq $0x1, %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x62a6
movq -0x28(%rbp), %rax
movq $0x0, 0x61a70(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop