LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/dwbuiten[P]obuparse/obuparse.c
// Function: obp_le
static inline uint64_t _obp_le(uint8_t *buf, uint8_t n)
{
    uint64_t t = 0;
    size_t pos = 0;
    for (uint8_t i = 0; i < n; i++) {
        uint8_t byte = buf[pos];
        t += ((uint64_t)byte) << (i * 8);
        pos++;
    }
    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
movzbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jge 0x470a
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x22(%rbp)
movzbl -0x22(%rbp), %eax
movzbl -0x21(%rbp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shlq %cl, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movb -0x21(%rbp), %al
addb $0x1, %al
movb %al, -0x21(%rbp)
jmp 0x46c2
movq -0x18(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/dwbuiten[P]obuparse/obuparse.c
// Function: obp_parse_frame
int obp_parse_frame(uint8_t *buf, size_t buf_size, OBPSequenceHeader *seq, OBPState *state,
                    int temporal_id, int spatial_id, OBPFrameHeader *fh, OBPTileGroup *tile_group,
                    int *SeenFrameHeader, OBPError *err)
{
    size_t startBitPos = 0, endBitPos, headerBytes;
    int ret = obp_parse_frame_header(buf, buf_size, seq, state, temporal_id, spatial_id, fh, SeenFrameHeader, err);
    if (ret < 0) {
        return -1;
    }
    endBitPos   = state->frame_header_end_pos;
    headerBytes = (endBitPos - startBitPos) / 8;
    return obp_parse_tile_group(buf + headerBytes, buf_size - headerBytes, fh, tile_group, SeenFrameHeader, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl %r9d, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
movl -0x30(%rbp), %r9d
movq 0x10(%rbp), %r11
movq 0x20(%rbp), %r10
movq 0x28(%rbp), %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x1070
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
jge 0x62d1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6318
movq -0x28(%rbp), %rax
movq 0x460(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
subq -0x38(%rbp), %rax
shrq $0x3, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
subq -0x48(%rbp), %rsi
movq 0x10(%rbp), %rdx
movq 0x18(%rbp), %rcx
movq 0x20(%rbp), %r8
movq 0x28(%rbp), %r9
callq 0x1080
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dwbuiten[P]obuparse/obuparse.c
// Function: obp_get_relative_dist
static inline int32_t _obp_get_relative_dist(int32_t a, int32_t b, OBPSequenceHeader *seq)
{
    int32_t diff, m;

    if (!seq->enable_order_hint)
        return 0;

    diff = a - b;
    m    = 1 << (seq->OrderHintBits - 1);
    diff = (diff & (m - 1)) - (diff & m);

    return diff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4e8(%rax)
jne 0xe564
movl $0x0, -0x4(%rbp)
jmp 0xe5a1
movl -0x8(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x505(%rax), %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl -0x1c(%rbp), %ecx
andl -0x20(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dwbuiten[P]obuparse/obuparse.c
// Function: obp_ns
static inline int _obp_ns(_OBPBitReader *br, uint32_t n, uint32_t *out, OBPError *err)
{
    uint32_t w = _obp_floor_log2(n) + 1;
    uint32_t m = (((uint32_t)1) << w) - n;
    uint32_t v;
    uint32_t extra_bit;

    assert(w - 1 <= 32);
    _obp_br(v, br, ((uint8_t)(w - 1)));
    if (v < m) {
        *out = v;
        return 0;
    }
    _obp_br(extra_bit, br, 1);
    *out = (v << 1) - m + extra_bit;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x14(%rbp), %edi
callq 0xebd0
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
subl $0x1, %eax
cmpl $0x20, %eax
ja 0xe5f2
jmp 0xe611
leaq 0xf15(%rip), %rdi       # 0xf50e
leaq 0xab7(%rip), %rsi       # 0xf0b7
movl $0xc2, %edx
leaq 0xf0e(%rip), %rcx       # 0xf51a
callq 0x1040
jmp 0xe613
movl -0x2c(%rbp), %eax
subl $0x1, %eax
movzbl %al, %eax
movq -0x10(%rbp), %rcx
movzbl 0x20(%rcx), %ecx
subl %ecx, %eax
addl $0x8, %eax
subl $0x1, %eax
sarl $0x3, %eax
cltq
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x10(%rbp), %rdx
subq 0x10(%rdx), %rcx
cmpq %rcx, %rax
jbe 0xe677
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xaf5(%rip), %rdx       # 0xf159
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe731
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %eax
subl $0x1, %eax
movzbl %al, %esi
callq 0x3c20
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x30(%rbp), %eax
jae 0xe6a9
movl -0x34(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0xe731
jmp 0xe6ab
movq -0x10(%rbp), %rax
movzbl 0x20(%rax), %ecx
movl $0x1, %eax
subl %ecx, %eax
addl $0x8, %eax
subl $0x1, %eax
sarl $0x3, %eax
cltq
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x10(%rbp), %rdx
subq 0x10(%rdx), %rcx
cmpq %rcx, %rax
jbe 0xe708
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xa61(%rip), %rdx       # 0xf159
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe731
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x3c20
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %ecx
shll %ecx
subl -0x30(%rbp), %ecx
addl -0x38(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dwbuiten[P]obuparse/obuparse.c
// Function: obp_read_delta_q
static inline int _obp_read_delta_q(_OBPBitReader *br, int32_t *out, OBPError *err)
{
    int delta_coded;
    _obp_br(delta_coded, br, 1);
    if (delta_coded) {
        int32_t val;
        int ret = _obp_su(br, 7, &val, err);
        if (ret < 0)
            return ret;
        *out = val;
    } else {
        *out = 0;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x20(%rax), %ecx
movl $0x1, %eax
subl %ecx, %eax
addl $0x8, %eax
subl $0x1, %eax
sarl $0x3, %eax
cltq
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x10(%rbp), %rdx
subq 0x10(%rdx), %rcx
cmpq %rcx, %rax
jbe 0xe7b1
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x9b8(%rip), %rdx       # 0xf159
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe80b
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x3c20
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0xe7fa
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rcx
movl $0x7, %esi
leaq -0x34(%rbp), %rdx
callq 0xe820
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
jge 0xe7ef
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xe80b
movl -0x34(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0xe804
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dwbuiten[P]obuparse/obuparse.c
// Function: obp_su
static inline int _obp_su(_OBPBitReader *br, uint32_t n, int32_t *out, OBPError *err)
{
    int32_t value;
    uint32_t signMask;

    _obp_br(value, br, n);
    signMask = ((uint32_t)1) << (n - 1);
    if (value & signMask) {
        value = value - 2 * signMask;
    }
    *out = value;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movzbl 0x20(%rcx), %ecx
subl %ecx, %eax
addl $0x8, %eax
subl $0x1, %eax
shrl $0x3, %eax
movl %eax, %eax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x10(%rbp), %rdx
subq 0x10(%rdx), %rcx
cmpq %rcx, %rax
jbe 0xe892
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x8d7(%rip), %rdx       # 0xf159
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe8dc
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movzbl %al, %esi
callq 0x3c20
movl %eax, -0x2c(%rbp)
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
andl -0x30(%rbp), %eax
cmpl $0x0, %eax
je 0xe8cc
movl -0x2c(%rbp), %eax
movl -0x30(%rbp), %ecx
shll %ecx
subl %ecx, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dwbuiten[P]obuparse/obuparse.c
// Function: obp_get_qindex
static inline uint8_t _obp_get_qindex(int ignoreDeltaQ, int segmentId, int16_t CurrentQIndex, OBPFrameHeader *fh, int FeatureEnabled[8][8], int16_t FeatureData[8][8])
{
    if (fh->segmentation_params.segmentation_enabled && FeatureEnabled[segmentId][0]) {
        int16_t data   = FeatureData[segmentId][0];
        int32_t qindex = data + ((int32_t) fh->quantization_params.base_q_idx);
        if (ignoreDeltaQ == 0 && fh->delta_q_params.delta_q_present == 1) {
            qindex = CurrentQIndex + data;
        }
        return _OBP_MAX(0, _OBP_MIN(255, qindex));
    }

    if (ignoreDeltaQ == 0 && fh->delta_q_params.delta_q_present == 1) {
        return CurrentQIndex;
    }

    return fh->quantization_params.base_q_idx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %dx, %ax
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movw %ax, -0xe(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x13c(%rax)
je 0xe9d2
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpl $0x0, (%rax)
je 0xe9d2
movq -0x28(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movw (%rax), %ax
movw %ax, -0x2a(%rbp)
movswl -0x2a(%rbp), %eax
movq -0x18(%rbp), %rcx
movzbl 0x12c(%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0xe980
movq -0x18(%rbp), %rax
cmpl $0x1, 0x14c(%rax)
jne 0xe980
movswl -0xe(%rbp), %eax
movswl -0x2a(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x30(%rbp)
movl $0xff, %eax
cmpl -0x30(%rbp), %eax
jge 0xe994
movl $0xff, %eax
movl %eax, -0x34(%rbp)
jmp 0xe99a
movl -0x30(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jle 0xe9aa
xorl %eax, %eax
movl %eax, -0x38(%rbp)
jmp 0xe9ca
movl $0xff, %eax
cmpl -0x30(%rbp), %eax
jge 0xe9be
movl $0xff, %eax
movl %eax, -0x3c(%rbp)
jmp 0xe9c4
movl -0x30(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movb %al, -0x1(%rbp)
jmp 0xe9fb
cmpl $0x0, -0x8(%rbp)
jne 0xe9ee
movq -0x18(%rbp), %rax
cmpl $0x1, 0x14c(%rax)
jne 0xe9ee
movw -0xe(%rbp), %ax
movb %al, -0x1(%rbp)
jmp 0xe9fb
movq -0x18(%rbp), %rax
movb 0x12c(%rax), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/dwbuiten[P]obuparse/obuparse.c
// Function: obp_floor_log2
static inline uint32_t _obp_floor_log2(uint32_t a)
{
    uint32_t s = 0;
    uint32_t x = a;
    while (x != 0) {
        x = x >> 1;
        s++;
    }
    return s - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xebfd
movl -0xc(%rbp), %eax
shrl %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xebe4
movl -0x8(%rbp), %eax
subl $0x1, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dwbuiten[P]obuparse/obuparse.c
// Function: obp_decode_signed_subexp_with_ref
static inline int _obp_decode_signed_subexp_with_ref(_OBPBitReader *br, int32_t low, int32_t high, int32_t r, int16_t *out, OBPError *err) {
    int16_t val;
    int ret = _obp_decode_unsigned_subexp_with_ref(br, high - low, r - low, &val, err);
    if (ret < 0) {
        return -1;
    }
    *out = val + low;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
subl -0x14(%rbp), %esi
movl -0x1c(%rbp), %edx
subl -0x14(%rbp), %edx
movq -0x30(%rbp), %r8
leaq -0x32(%rbp), %rcx
callq 0xec80
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
jge 0xec5c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xec74
movswl -0x32(%rbp), %eax
addl -0x14(%rbp), %eax
movw %ax, %cx
movq -0x28(%rbp), %rax
movw %cx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dwbuiten[P]obuparse/obuparse.c
// Function: obp_decode_unsigned_subexp_with_ref
static inline int _obp_decode_unsigned_subexp_with_ref(_OBPBitReader *br, int32_t mx, int32_t r, int16_t *out, OBPError *err) {
    uint32_t v;
    int ret = _obp_decode_subexp(br, mx, &v, err);
    if (ret < 0) {
        return -1;
    }
    if (r < 0) { /* avoid signed shift */
        if (-(-r << 1) <= mx) {
            *out = _obps_inverse_recenter(r, v);
            return 0;
        }
    }
    if ((r << 1) <= mx) {
        *out = _obps_inverse_recenter(r, v);
        return 0;
    } else {
        *out = mx - 1 - _obps_inverse_recenter(mx - 1 - r, v);
        return 0;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x28(%rbp), %rcx
leaq -0x2c(%rbp), %rdx
callq 0xed60
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jge 0xecc3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xed53
cmpl $0x0, -0x18(%rbp)
jge 0xecf9
xorl %ecx, %ecx
subl -0x18(%rbp), %ecx
shll %ecx
xorl %eax, %eax
subl %ecx, %eax
cmpl -0x14(%rbp), %eax
jg 0xecf7
movl -0x18(%rbp), %edi
movl -0x2c(%rbp), %esi
callq 0xef60
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0xed53
jmp 0xecf9
movl -0x18(%rbp), %eax
shll %eax
cmpl -0x14(%rbp), %eax
jg 0xed21
movl -0x18(%rbp), %edi
movl -0x2c(%rbp), %esi
callq 0xef60
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0xed53
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x14(%rbp), %edi
subl $0x1, %edi
subl -0x18(%rbp), %edi
movl -0x2c(%rbp), %esi
callq 0xef60
movl %eax, %ecx
movl -0x34(%rbp), %eax
subl %ecx, %eax
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dwbuiten[P]obuparse/obuparse.c
// Function: obps_inverse_recenter
static inline int32_t _obps_inverse_recenter(int32_t r, uint32_t v)
{
    if (((uint64_t)v) > ((uint64_t)(2 * r))) {
        return (int32_t) v;
    } else if (v & 1) {
        return r - ((v + 1) >> 1);
    } else {
        return r + (v >> 1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl -0x8(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jbe 0xef82
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xefac
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xef9f
movl -0x8(%rbp), %eax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
shrl %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xefac
movl -0x8(%rbp), %eax
movl -0xc(%rbp), %ecx
shrl %ecx
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: pr_sanityOfFlow
int pr_sanityOfFlow(struct Graph* g, struct Vertex* s, struct Vertex* t, FILE* out) {
	int sOuttIn = s->visited + t->visited;

	int excessViolated = 0;
	for (int vi=0; vi<g->n; ++vi) {
		struct Vertex* v = g->vertices[vi];
		if ((v != s) && (v != t)) {
			if (v->visited != 0) {
				++excessViolated;
			}
		}
	}

	if (out) {
		fprintf(out, "excess s: %i, excess t:%i, violations in between: %i\n", s->visited, t->visited, excessViolated);
	}

	return !sOuttIn && !excessViolated;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movl 0x1c(%rax), %eax
movq 0x30(%rsp), %rcx
addl 0x1c(%rcx), %eax
movl %eax, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x40(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x143f
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x38(%rsp), %rax
je 0x1430
movq 0x10(%rsp), %rax
cmpq 0x30(%rsp), %rax
je 0x1430
movq 0x10(%rsp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x142e
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x1430
jmp 0x1432
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x13dc
cmpq $0x0, 0x28(%rsp)
je 0x146f
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rax
movl 0x1c(%rax), %edx
movq 0x30(%rsp), %rax
movl 0x1c(%rax), %ecx
movl 0x20(%rsp), %r8d
leaq 0x33b9c(%rip), %rsi     # 0x35004
movb $0x0, %al
callq 0x1140
xorl %eax, %eax
cmpl $0x0, 0x24(%rsp)
movb %al, 0xf(%rsp)
jne 0x148a
cmpl $0x0, 0x20(%rsp)
setne %al
xorb $-0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: pr_sanityOfFinalActiveArray
int pr_sanityOfFinalActiveArray(struct ShallowGraph** activeVertices, int nLists, FILE* out) {
	int forgottenVertices = 0;
	for (int i=0; i<nLists; ++i) {
		if (peekFromVertexQueue(activeVertices[i])) {
			forgottenVertices += activeVertices[i]->m;
			if (out) {
				fprintf(out, "Level %i: Vertex %i\n", i, peekFromVertexQueue(activeVertices[i])->number);
			}
		}
	}
	if (out) {
		fprintf(out, "total of forgotten vertices: %i\n", forgottenVertices);
	}
	return forgottenVertices;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x155d
movq 0x30(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x32930
cmpq $0x0, %rax
je 0x154b
movq 0x30(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x10(%rax), %eax
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x1549
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x32930
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %edx
movl 0x18(%rax), %ecx
leaq 0x33af8(%rip), %rsi     # 0x3503a
movb $0x0, %al
callq 0x1140
jmp 0x154b
jmp 0x154d
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x14c2
cmpq $0x0, 0x20(%rsp)
je 0x157c
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %edx
leaq 0x33ada(%rip), %rsi     # 0x3504f
movb $0x0, %al
callq 0x1140
movl 0x1c(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: pr_init
static struct ShallowGraph** pr_init(struct Graph* g, struct Vertex* s, struct ShallowGraphPool* sgp) {

	struct ShallowGraph** activeVertices = malloc((2 * g->n - 1) * sizeof(struct ShallowGraph*));
	for (int i=0; i<2 * g->n - 1; ++i) {
		activeVertices[i] = getShallowGraph(sgp);
	}

	// set distance label to n
	s->d = g->n;

	for (struct VertexList* e=s->neighborhood; e!=NULL; e=e->next) {
		// set preflow of out edges to max
		addFlow(e, e->used);
		// add excess to s and endPoint
		e->endPoint->visited += e->flag;
		s->visited -= e->flag;
		addToVertexQueue(e->endPoint, activeVertices[0], sgp);
	}
	return activeVertices;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movl (%rax), %eax
shll %eax
subl $0x1, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x1170
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x30(%rsp), %rcx
movl (%rcx), %ecx
shll %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x17d4
movq 0x20(%rsp), %rdi
callq 0x1fe70
movq %rax, %rdx
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1798
movq 0x30(%rsp), %rax
movl (%rax), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x28(%rax)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1862
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x20(%rax), %esi
callq 0x1370
movq 0x8(%rsp), %rax
movl 0x24(%rax), %ecx
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
addl 0x1c(%rax), %ecx
movl %ecx, 0x1c(%rax)
movq 0x8(%rsp), %rax
movl 0x24(%rax), %edx
movq 0x28(%rsp), %rax
movl 0x1c(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x1c(%rax)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
movq 0x20(%rsp), %rdx
callq 0x32870
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x17f1
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: pr_push
static void pr_push(struct VertexList* e, struct Vertex* s, struct Vertex* t, struct ShallowGraph** activeVertices, struct ShallowGraphPool* sgp) {
	// compute pushable flow
	int flow = min(e->startPoint->visited, e->used - e->flag);

	// add endPoint to list of active vertices, if it becomes active now
	if (pr_vertexBecomesActive(e->endPoint, s, t)) {
		addToVertexQueue(e->endPoint, activeVertices[e->endPoint->d], sgp);
	}

	// augment preflow by flow
	addFlow(e, flow);
	e->startPoint->visited -= flow;
	e->endPoint->visited += flow;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x1c(%rax), %edi
movq 0x30(%rsp), %rax
movl 0x20(%rax), %esi
movq 0x30(%rsp), %rax
subl 0x24(%rax), %esi
callq 0xda10
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x25c0
cmpl $0x0, %eax
je 0x1968
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
movq 0x18(%rcx), %rcx
movslq 0x28(%rcx), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x10(%rsp), %rdx
callq 0x32870
movq 0x30(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x1370
movl 0xc(%rsp), %edx
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x1c(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x1c(%rax)
movl 0xc(%rsp), %ecx
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
addl 0x1c(%rax), %ecx
movl %ecx, 0x1c(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: pr_relabel
static int pr_relabel(struct Vertex* v) {
	int newDistance = INT_MAX;
	for (struct VertexList* e=v->neighborhood; e!=NULL; e=e->next) {
		if ((e->endPoint->d < newDistance) && (e->used - e->flag > 0)) {
			newDistance = e->endPoint->d + 1;
		}
	}
	v->d = newDistance;
	return newDistance;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x7fffffff, -0xc(%rsp) # imm = 0x7FFFFFFF
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, -0x18(%rsp)
je 0x1a1f
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x28(%rax), %eax
cmpl -0xc(%rsp), %eax
jge 0x1a0d
movq -0x18(%rsp), %rax
movl 0x20(%rax), %eax
movq -0x18(%rsp), %rcx
subl 0x24(%rcx), %eax
cmpl $0x0, %eax
jle 0x1a0d
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x28(%rax), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x1a0f
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rsp)
jmp 0x19cb
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x28(%rax)
movl -0xc(%rsp), %eax
retq
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: pr_findSmallestActiveIndex
static int pr_findSmallestActiveIndex(struct ShallowGraph** activeVertices, int i) {
	int j = i-1;
	for ( ; j>0; --j) {
		if (peekFromVertexQueue(activeVertices[j]) != NULL) {
			break;
		}
	}
	return j;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl 0xc(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jle 0x1a79
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x32930
cmpq $0x0, %rax
je 0x1a6a
jmp 0x1a79
jmp 0x1a6c
movl 0x8(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x1a48
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: augment
char augment(struct Vertex* s, struct Vertex* t) {
	struct VertexList* e;

	if (s == t) {
		return 1;
	}
	s->visited = 1;
	for (e=s->neighborhood; e!=NULL; e=e->next) {
		if ((e->flag == 0) && (e->endPoint->visited == 0)) {
			char found = augment(e->endPoint, t);
			if (found) {
				setFlag(e, 1);
				s->visited = 0;
				return 1;
			}
		}
	}
	s->visited = 0;
	return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x1ab4
movb $0x1, 0x27(%rsp)
jmp 0x1b55
movq 0x18(%rsp), %rax
movl $0x1, 0x1c(%rax)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1b44
movq 0x8(%rsp), %rax
cmpl $0x0, 0x24(%rax)
jne 0x1b32
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
cmpl $0x0, 0x1c(%rax)
jne 0x1b32
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x1a90
movb %al, 0x7(%rsp)
cmpb $0x0, 0x7(%rsp)
je 0x1b30
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x1340
movq 0x18(%rsp), %rax
movl $0x0, 0x1c(%rax)
movb $0x1, 0x27(%rsp)
jmp 0x1b55
jmp 0x1b32
jmp 0x1b34
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x1ace
movq 0x18(%rsp), %rax
movl $0x0, 0x1c(%rax)
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: augmentWithCapacity
char augmentWithCapacity(struct Vertex* s, struct Vertex* t) {
	if (s == t) {
		return 1;
	}

	s->visited = 1;
	for (struct VertexList* e=s->neighborhood; e!=NULL; e=e->next) {
		if ((e->flag < e->used) && (e->endPoint->visited == 0)) {
			char found = augmentWithCapacity(e->endPoint, t);
			if (found) {
				addFlow(e, 1);
				s->visited = 0;
				return 1;
			}
		}
	}
	s->visited = 0;
	return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x1b84
movb $0x1, 0x27(%rsp)
jmp 0x1c2c
movq 0x18(%rsp), %rax
movl $0x1, 0x1c(%rax)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1c1b
movq 0x8(%rsp), %rax
movl 0x24(%rax), %eax
movq 0x8(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x1c09
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
cmpl $0x0, 0x1c(%rax)
jne 0x1c09
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x1b60
movb %al, 0x7(%rsp)
cmpb $0x0, 0x7(%rsp)
je 0x1c07
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x1370
movq 0x18(%rsp), %rax
movl $0x0, 0x1c(%rax)
movb $0x1, 0x27(%rsp)
jmp 0x1c2c
jmp 0x1c09
jmp 0x1c0b
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x1b9e
movq 0x18(%rsp), %rax
movl $0x0, 0x1c(%rax)
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: getMatchedVertex
struct Vertex* getMatchedVertex(struct Vertex* a) {
	struct VertexList* e;
	for (e=a->neighborhood; e!=NULL; e=e->next) {
		if (e->flag == 1) {
			return e->endPoint;
		}
	}
	return NULL;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, -0x18(%rsp)
je 0x1c88
movq -0x18(%rsp), %rax
cmpl $0x1, 0x24(%rax)
jne 0x1c76
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1c91
jmp 0x1c78
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rsp)
jmp 0x1c53
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: addResidualEdges
void addResidualEdges(struct Vertex* v, struct Vertex* w, struct ListPool* lp) {
	struct VertexList* f1;
	struct VertexList* f2;

	f1 = getVertexList(lp);
	f1->startPoint = v;
	f1->endPoint = w;
	f2 = inverseEdge(f1, lp);

	f1->flag = 0;
	f2->flag = 1;
	f1->label = (char*)f2;
	f2->label = (char*)f1;

	addEdge(v, f1);
	addEdge(w, f2);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1f310
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xa370
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movl $0x0, 0x24(%rax)
movq (%rsp), %rax
movl $0x1, 0x24(%rax)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xa660
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
callq 0xa660
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: addResidualEdgesWithCapacity
void addResidualEdgesWithCapacity(struct Vertex* v, struct Vertex* w, int capacity, struct ListPool* lp) {
	struct VertexList* f1;
	struct VertexList* f2;

	f1 = getVertexList(lp);
	f1->startPoint = v;
	f1->endPoint = w;
	f2 = inverseEdge(f1, lp);

	f1->used = capacity;
	f2->used = capacity;
	f1->flag = 0;
	f2->flag = capacity;
	f1->label = (char*)f2;
	f2->label = (char*)f1;

	addEdge(v, f1);
	addEdge(w, f2);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1f310
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xa370
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x20(%rax)
movl 0x24(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x24(%rax)
movl 0x24(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x24(%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xa660
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xa660
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: _cloneStrangeBipartite
struct Graph* __cloneStrangeBipartite(struct Graph* g, struct GraphPool* gp) {
	int v; 
	struct VertexList* e;
	struct Graph* h = createGraph(g->n, gp);
	h->number = g->number;
	h->m = g->m;

	for (v=0; v<g->number; ++v) {
		for (e=g->vertices[v]->neighborhood; e!=NULL; e=e->next) {		
			addResidualEdges(h->vertices[v], h->vertices[e->endPoint->number], gp->listPool);
		}
	}
	return h;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %edi
movq 0x18(%rsp), %rsi
callq 0xb850
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movl 0x8(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x20(%rsp), %rax
movl 0x4(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0x4(%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x1f14
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1f02
movq (%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x18(%rcx), %rcx
movslq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdx
callq 0x1cc0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x1eb2
jmp 0x1f04
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1e89
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: initBipartite
void initBipartite(struct Graph* B) {
	int i;
	struct VertexList* e;
	for (i=0; i<B->number; ++i) {
		for (e=B->vertices[i]->neighborhood; e!=NULL; e=e->next) {
			setFlag(e, 0);
		}
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x1f88
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x1f79
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x1340
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
jmp 0x1f59
jmp 0x1f7b
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1f31
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: removeSandT
void removeSandT(struct Graph* B, struct Vertex* s, struct Vertex* t, struct GraphPool* gp) {	
	int w;

	for (w=0; w<B->number; ++w) {
		removeEdge(B->vertices[w], s, gp->listPool);
	}

	for (w=B->number; w<B->n; ++w) {
		removeEdge(B->vertices[w], t, gp->listPool);
	}

	dumpVertexListRecursively(gp->listPool, s->neighborhood);
	dumpVertexListRecursively(gp->listPool, t->neighborhood);

	dumpVertex(gp->vertexPool, s);
	dumpVertex(gp->vertexPool, t);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x1ff0
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdx
callq 0xa6a0
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1fb0
movq 0x20(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x203b
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdx
callq 0xa6a0
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1ffc
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x1f460
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x1f460
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x1f810
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x1f810
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: bipartiteMatchingFastAndDirty
int bipartiteMatchingFastAndDirty(struct Graph* g, struct GraphPool* gp) {
	int v;
	int matchingSize = 0;

	struct Vertex* s = getVertex(gp->vertexPool);
	struct Vertex* t = getVertex(gp->vertexPool);
	s->number = -1;
	t->number = -2;

	/* Add s, t and edges from s to A and from B to t.
	Also, set residual capacities for these edges correctly */
	for (v=0; v<g->number; ++v) {
		addResidualEdges(s, g->vertices[v], gp->listPool);
	}

	for (v=g->number; v<g->n; ++v) {
		addResidualEdges(g->vertices[v], t, gp->listPool);
	}

	while (augment(s, t)) {
		++matchingSize;
	}

	removeSandT(g, s, t, gp);

	return matchingSize;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1f6a0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1f6a0
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
movq (%rsp), %rax
movl $0xfffffffe, 0x18(%rax) # imm = 0xFFFFFFFE
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x213a
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdx
callq 0x1cc0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x20fa
movq 0x20(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x2184
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq (%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdx
callq 0x1cc0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2146
jmp 0x2186
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x1a90
cmpb $0x0, %al
je 0x21a5
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x2186
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x1f90
movl 0x10(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: bipartiteMatchingEvenMoreDirty
int bipartiteMatchingEvenMoreDirty(struct Graph* g) {
	int matchingSize = 0;
	int activity = g->activity;
	while (augment_B(g)) {
		++matchingSize;
	}
	g->activity = activity;
	return matchingSize;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2220
cmpb $0x0, %al
je 0x2208
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x21ed
movl 0x8(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xc(%rax)
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: augment_B
static char augment_B(struct Graph* B) {
	for (int v=B->activity; v<B->number; ++v) {
		if (B->vertices[v]->d == 0) {
			char found = augment_B_rec(B, B->vertices[v]);
			if (found) {
				B->activity = v+1;
				B->vertices[v]->d = 1;
				return 1;
			}
		}
	}
	B->activity = B->number;
	return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x22c9
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x28(%rax)
jne 0x22b7
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x2390
movb %al, 0x3(%rsp)
cmpb $0x0, 0x3(%rsp)
je 0x22b5
movl 0x4(%rsp), %ecx
addl $0x1, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x1, 0x28(%rax)
movb $0x1, 0x17(%rsp)
jmp 0x22de
jmp 0x22b7
jmp 0x22b9
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2235
movq 0x8(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0xc(%rax)
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: bipartiteMatchingTerminateEarly
char bipartiteMatchingTerminateEarly(struct Graph* B) {

	for (int v=0; v<B->number; ++v) {
		if (B->vertices[v]->d == 0) {
			char found = augment_B_rec(B, B->vertices[v]);
			if (found) {
				B->vertices[v]->d = 1;
			} else {
				return 0;
			}
		}
	}
	return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x2381
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x28(%rax)
jne 0x2372
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x2390
movb %al, 0x3(%rsp)
cmpb $0x0, 0x3(%rsp)
je 0x2369
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x1, 0x28(%rax)
jmp 0x2370
movb $0x0, 0x17(%rsp)
jmp 0x2386
jmp 0x2372
jmp 0x2374
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2301
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: augment_B_rec
static char augment_B_rec(struct Graph* B, struct Vertex* v) {
	struct VertexList* e;

	if ((v->number >= B->number) && (v->d == 0)) {
		v->d = 1;
		return 1;
	}
	v->visited = 1;
	for (e=v->neighborhood; e!=NULL; e=e->next) {
		if ((e->flag == 0) && (e->endPoint->visited == 0)) {
			char found = augment_B_rec(B, e->endPoint);
			if (found) {
				setFlag(e, 1);
				v->visited = 0;
				return 1;
			}
		}
	}
	v->visited = 0;
	return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0x18(%rax), %eax
movq 0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jl 0x23d1
movq 0x10(%rsp), %rax
cmpl $0x0, 0x28(%rax)
jne 0x23d1
movq 0x10(%rsp), %rax
movl $0x1, 0x28(%rax)
movb $0x1, 0x27(%rsp)
jmp 0x2472
movq 0x10(%rsp), %rax
movl $0x1, 0x1c(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2461
movq 0x8(%rsp), %rax
cmpl $0x0, 0x24(%rax)
jne 0x244f
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
cmpl $0x0, 0x1c(%rax)
jne 0x244f
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x2390
movb %al, 0x7(%rsp)
cmpb $0x0, 0x7(%rsp)
je 0x244d
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x1340
movq 0x10(%rsp), %rax
movl $0x0, 0x1c(%rax)
movb $0x1, 0x27(%rsp)
jmp 0x2472
jmp 0x244f
jmp 0x2451
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x23eb
movq 0x10(%rsp), %rax
movl $0x0, 0x1c(%rax)
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: getMatching
struct ShallowGraph* getMatching(struct Graph* g, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* matching = getShallowGraph(sgp);
	struct VertexList* e;
	int v;
	
	for (v=0; v<g->number; ++v) {
		for (e=g->vertices[v]->neighborhood; e!=NULL; e=e->next) {
			if (e->flag == 1) {
				struct VertexList* f = shallowCopyEdge(e, sgp->listPool);
				f->label = NULL;
				appendEdge(matching, f);
			}
		}
	}
	return matching;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1fe70
movq %rax, 0x20(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x253c
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x252a
movq 0x18(%rsp), %rax
cmpl $0x1, 0x24(%rax)
jne 0x2518
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa310
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xbf70
jmp 0x251a
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x24d2
jmp 0x252c
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x24a5
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: bipartiteMatching
struct ShallowGraph* bipartiteMatching(struct Graph* h, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* matching;
	struct Graph* g = __cloneStrangeBipartite(h, gp);

	bipartiteMatchingFastAndDirty(g, gp);
	matching = getMatching(g, sgp);
	rebaseShallowGraphs(matching, h); 

	/* garbage collection */
	dumpGraph(gp, g);

	return matching;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1e40
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x20a0
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2480
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xbc00
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
callq 0x1fb30
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/bitSet.c
// Function: createBitset
uint8_t* createBitset(size_t n) {
	uint8_t* bitset;
	if (n % 8 == 0) {
		bitset = calloc((n / 8), sizeof(uint8_t));
	} else {
		bitset = calloc((n / 8 + 1), sizeof(uint8_t));
	} 
	return bitset;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0x2652
movq 0x10(%rsp), %rdi
shrq $0x3, %rdi
movl $0x1, %esi
callq 0x1100
movq %rax, 0x8(%rsp)
jmp 0x266e
movq 0x10(%rsp), %rdi
shrq $0x3, %rdi
addq $0x1, %rdi
movl $0x1, %esi
callq 0x1100
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/bitSet.c
// Function: copyBitset
uint8_t* copyBitset(uint8_t* bitset, size_t n) {
	uint8_t* copy = createBitset(n);
	size_t nBytes = (n % 8 == 0) ? (n / 8) : (n / 8 + 1);
	memcpy(copy, bitset, nBytes);
	return copy;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x2620
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0x26bb
movq 0x18(%rsp), %rax
shrq $0x3, %rax
movq %rax, (%rsp)
jmp 0x26cc
movq 0x18(%rsp), %rax
shrq $0x3, %rax
addq $0x1, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x1150
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/bitSet.c
// Function: setBit
void setBit(uint8_t* bitset, size_t i, uint8_t value) {
	if (value) {
		setBitTrue(bitset, i);
	} else {
		setBitFalse(bitset, i);
	}
}

// Assembly:
subq $0x18, %rsp
movb %dl, %al
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movb %al, 0x7(%rsp)
cmpb $0x0, 0x7(%rsp)
je 0x27bc
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2710
jmp 0x27cb
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2750
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/bitSet.c
// Function: printBitset
void printBitset(uint8_t* bitset, size_t n, FILE* out) {
	fprintf(out, "[");
	for (size_t i=0; i<n; ++i) {
		fprintf(out, "%i", getBit(bitset, i));
	}
	fprintf(out, "]\n");
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x33ee9(%rip), %rsi     # 0x36718
movb $0x0, %al
callq 0x1140
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x2888
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x27d0
movq (%rsp), %rdi
movzbl %al, %edx
leaq 0x33d83(%rip), %rsi     # 0x365f4
movb $0x0, %al
callq 0x1140
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x283f
movq 0x10(%rsp), %rdi
leaq 0x33f53(%rip), %rsi     # 0x367e7
movb $0x0, %al
callq 0x1140
addq $0x28, %rsp
retq