LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_uint16
uint_fast16_t float64_to_uint16(float64 a, float_status *status)
{
    int64_t v;
    uint_fast16_t res;
    int old_exc_flags = get_float_exception_flags(status);

    v = float64_to_int32(a, status);
    if (v < 0) {
        res = 0;
    } else if (v > 0xffff) {
        res = 0xffff;
    } else {
        return v;
    }

    set_float_exception_flags(old_exc_flags, status);
    float_raise(float_flag_invalid, status);
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x22610
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x16830
cltq
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0x22bf0
movq $0x0, -0x28(%rbp)
jmp 0x22c10
cmpq $0xffff, -0x20(%rbp)    # imm = 0xFFFF
jle 0x22c04
movq $0xffff, -0x28(%rbp)    # imm = 0xFFFF
jmp 0x22c0e
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x22c32
jmp 0x22c10
movl -0x2c(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x22630
movq -0x18(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_uint16_round_to_zero
uint_fast16_t float64_to_uint16_round_to_zero(float64 a, float_status *status)
{
    int64_t v;
    uint_fast16_t res;
    int old_exc_flags = get_float_exception_flags(status);

    v = float64_to_int64_round_to_zero(a, status);
    if (v < 0) {
        res = 0;
    } else if (v > 0xffff) {
        res = 0xffff;
    } else {
        return v;
    }
    set_float_exception_flags(old_exc_flags, status);
    float_raise(float_flag_invalid, status);
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x22610
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x16d00
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0x22c7e
movq $0x0, -0x28(%rbp)
jmp 0x22c9e
cmpq $0xffff, -0x20(%rbp)    # imm = 0xFFFF
jle 0x22c92
movq $0xffff, -0x28(%rbp)    # imm = 0xFFFF
jmp 0x22c9c
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x22cc0
jmp 0x22c9e
movl -0x2c(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x22630
movq -0x18(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_scalbn
float32 float32_scalbn(float32 a, int n, float_status *status)
{
    flag aSign;
    int16_t aExp;
    uint32_t aSig;

    a = float32_squash_input_denormal(a, status);
    aSig = extractFloat32Frac( a );
    aExp = extractFloat32Exp( a );
    aSign = extractFloat32Sign( a );

    if ( aExp == 0xFF ) {
        if ( aSig ) {
            return propagateFloat32NaN(a, a, status);
        }
        return a;
    }
    if (aExp != 0) {
        aSig |= 0x00800000;
    } else if (aSig == 0) {
        return a;
    } else {
        aExp++;
    }

    if (n > 0x200) {
        n = 0x200;
    } else if (n < -0x200) {
        n = -0x200;
    }

    aExp += n - 1;
    aSig <<= 7;
    return normalizeRoundAndPackFloat32(aSign, aExp, aSig, status);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x11570
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x115f0
movl %eax, -0x20(%rbp)
movl -0x8(%rbp), %edi
callq 0x115d0
movw %ax, -0x1c(%rbp)
movl -0x8(%rbp), %edi
callq 0x12810
movb %al, -0x19(%rbp)
movswl -0x1c(%rbp), %eax
cmpl $0xff, %eax
jne 0x23ca6
cmpl $0x0, -0x20(%rbp)
je 0x23c9b
movl -0x8(%rbp), %edi
movl -0x8(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x13be0
movl %eax, -0x4(%rbp)
jmp 0x23d2f
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x23d2f
movswl -0x1c(%rbp), %eax
cmpl $0x0, %eax
je 0x23cbc
movl -0x20(%rbp), %eax
orl $0x800000, %eax         # imm = 0x800000
movl %eax, -0x20(%rbp)
jmp 0x23cd8
cmpl $0x0, -0x20(%rbp)
jne 0x23cca
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x23d2f
movw -0x1c(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x1c(%rbp)
jmp 0x23cd8
cmpl $0x200, -0xc(%rbp)      # imm = 0x200
jle 0x23cea
movl $0x200, -0xc(%rbp)      # imm = 0x200
jmp 0x23cfc
cmpl $0xfffffe00, -0xc(%rbp) # imm = 0xFFFFFE00
jge 0x23cfa
movl $0xfffffe00, -0xc(%rbp) # imm = 0xFFFFFE00
jmp 0x23cfc
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movswl -0x1c(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
shll $0x7, %eax
movl %eax, -0x20(%rbp)
movb -0x19(%rbp), %al
movswq -0x1c(%rbp), %rsi
movl -0x20(%rbp), %edx
movq -0x18(%rbp), %rcx
movzbl %al, %edi
callq 0x11780
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_scalbn
float64 float64_scalbn(float64 a, int n, float_status *status)
{
    flag aSign;
    int16_t aExp;
    uint64_t aSig;

    a = float64_squash_input_denormal(a, status);
    aSig = extractFloat64Frac( a );
    aExp = extractFloat64Exp( a );
    aSign = extractFloat64Sign( a );

    if ( aExp == 0x7FF ) {
        if ( aSig ) {
            return propagateFloat64NaN(a, a, status);
        }
        return a;
    }
    if (aExp != 0) {
        aSig |= LIT64( 0x0010000000000000 );
    } else if (aSig == 0) {
        return a;
    } else {
        aExp++;
    }

    if (n > 0x1000) {
        n = 0x1000;
    } else if (n < -0x1000) {
        n = -0x1000;
    }

    aExp += n - 1;
    aSig <<= 10;
    return normalizeRoundAndPackFloat64(aSign, aExp, aSig, status);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x11610
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x116a0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11680
movw %ax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x168f0
movb %al, -0x21(%rbp)
movswl -0x24(%rbp), %eax
cmpl $0x7ff, %eax            # imm = 0x7FF
jne 0x23dc3
cmpq $0x0, -0x30(%rbp)
je 0x23db6
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x17f70
movq %rax, -0x8(%rbp)
jmp 0x23e5b
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x23e5b
movswl -0x24(%rbp), %eax
cmpl $0x0, %eax
je 0x23de0
movabsq $0x10000000000000, %rax # imm = 0x10000000000000
orq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x23dff
cmpq $0x0, -0x30(%rbp)
jne 0x23df1
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x23e5b
movw -0x24(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x24(%rbp)
jmp 0x23dff
cmpl $0x1000, -0x14(%rbp)    # imm = 0x1000
jle 0x23e11
movl $0x1000, -0x14(%rbp)    # imm = 0x1000
jmp 0x23e23
cmpl $0xfffff000, -0x14(%rbp) # imm = 0xFFFFF000
jge 0x23e21
movl $0xfffff000, -0x14(%rbp) # imm = 0xFFFFF000
jmp 0x23e23
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movswl -0x24(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x24(%rbp)
movq -0x30(%rbp), %rax
shlq $0xa, %rax
movq %rax, -0x30(%rbp)
movb -0x21(%rbp), %al
movswq -0x24(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rcx
movzbl %al, %edi
callq 0x11fa0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: floatx80_scalbn
floatx80 floatx80_scalbn(floatx80 a, int n, float_status *status)
{
    flag aSign;
    int32_t aExp;
    uint64_t aSig;

    aSig = extractFloatx80Frac( a );
    aExp = extractFloatx80Exp( a );
    aSign = extractFloatx80Sign( a );

    if ( aExp == 0x7FFF ) {
        if ( aSig<<1 ) {
            return propagateFloatx80NaN(a, a, status);
        }
        return a;
    }

    if (aExp == 0) {
        if (aSig == 0) {
            return a;
        }
        aExp++;
    }

    if (n > 0x10000) {
        n = 0x10000;
    } else if (n < -0x10000) {
        n = -0x10000;
    }

    aExp += n;
    return normalizeRoundAndPackFloatx80(status->floatx80_rounding_precision,
                                         aSign, aExp, aSig, 0, status);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %si, %ax
movq %rdi, -0x20(%rbp)
movw %ax, -0x18(%rbp)
movl %edx, -0x24(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movzwl -0x18(%rbp), %esi
callq 0x1ab30
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movzwl -0x18(%rbp), %esi
callq 0x1ab50
movl %eax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movzwl -0x18(%rbp), %esi
callq 0x1ab70
movb %al, -0x31(%rbp)
cmpl $0x7fff, -0x38(%rbp)    # imm = 0x7FFF
jne 0x23f0f
movq -0x40(%rbp), %rax
shlq %rax
cmpq $0x0, %rax
je 0x23efa
movq -0x30(%rbp), %r8
movq -0x20(%rbp), %rdi
movw -0x18(%rbp), %ax
movq -0x20(%rbp), %rdx
movzwl %ax, %esi
movzwl -0x18(%rbp), %ecx
callq 0x1b670
movq %rax, -0x10(%rbp)
movw %dx, -0x8(%rbp)
jmp 0x23f93
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x23f93
cmpl $0x0, -0x38(%rbp)
jne 0x23f37
cmpq $0x0, -0x40(%rbp)
jne 0x23f2e
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x23f93
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
cmpl $0x10000, -0x24(%rbp)   # imm = 0x10000
jle 0x23f49
movl $0x10000, -0x24(%rbp)   # imm = 0x10000
jmp 0x23f5b
cmpl $0xffff0000, -0x24(%rbp) # imm = 0xFFFF0000
jge 0x23f59
movl $0xffff0000, -0x24(%rbp) # imm = 0xFFFF0000
jmp 0x23f5b
movl -0x24(%rbp), %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movb 0x3(%rax), %sil
movb -0x31(%rbp), %al
movl -0x38(%rbp), %edx
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %r9
xorl %edi, %edi
movl %edi, %r8d
movsbl %sil, %edi
movzbl %al, %esi
callq 0x1d360
movq %rax, -0x10(%rbp)
movw %dx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movw -0x8(%rbp), %dx
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: float128_scalbn
float128 float128_scalbn(float128 a, int n, float_status *status)
{
    flag aSign;
    int32_t aExp;
    uint64_t aSig0, aSig1;

    aSig1 = extractFloat128Frac1( a );
    aSig0 = extractFloat128Frac0( a );
    aExp = extractFloat128Exp( a );
    aSign = extractFloat128Sign( a );
    if ( aExp == 0x7FFF ) {
        if ( aSig0 | aSig1 ) {
            return propagateFloat128NaN(a, a, status);
        }
        return a;
    }
    if (aExp != 0) {
        aSig0 |= LIT64( 0x0001000000000000 );
    } else if (aSig0 == 0 && aSig1 == 0) {
        return a;
    } else {
        aExp++;
    }

    if (n > 0x10000) {
        n = 0x10000;
    } else if (n < -0x10000) {
        n = -0x10000;
    }

    aExp += n - 1;
    return normalizeRoundAndPackFloat128( aSign, aExp, aSig0, aSig1
                                         , status);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x24(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1e410
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1e430
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1e450
movl %eax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1e470
movb %al, -0x31(%rbp)
cmpl $0x7fff, -0x38(%rbp)    # imm = 0x7FFF
jne 0x2405b
movq -0x40(%rbp), %rax
orq -0x48(%rbp), %rax
cmpq $0x0, %rax
je 0x24046
movq -0x30(%rbp), %r8
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x1f480
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x240f2
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x240f2
cmpl $0x0, -0x38(%rbp)
je 0x24075
movabsq $0x1000000000000, %rax  # imm = 0x1000000000000
orq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x240a0
cmpq $0x0, -0x40(%rbp)
jne 0x24095
cmpq $0x0, -0x48(%rbp)
jne 0x24095
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x240f2
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x240a0
cmpl $0x10000, -0x24(%rbp)   # imm = 0x10000
jle 0x240b2
movl $0x10000, -0x24(%rbp)   # imm = 0x10000
jmp 0x240c4
cmpl $0xffff0000, -0x24(%rbp) # imm = 0xFFFF0000
jge 0x240c2
movl $0xffff0000, -0x24(%rbp) # imm = 0xFFFF0000
jmp 0x240c4
movl -0x24(%rbp), %eax
subl $0x1, %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movb -0x31(%rbp), %al
movl -0x38(%rbp), %esi
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
movq -0x30(%rbp), %r8
movzbl %al, %edi
callq 0x12660
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfloat-specialize.h
// Function: pickNaN
static int pickNaN(flag aIsQNaN, flag aIsSNaN, flag bIsQNaN, flag bIsSNaN,
                    flag aIsLargerSignificand)
{
    /* This implements x87 NaN propagation rules:
     * SNaN + QNaN => return the QNaN
     * two SNaNs => return the one with the larger significand, silenced
     * two QNaNs => return the one with the larger significand
     * SNaN and a non-NaN => return the SNaN, silenced
     * QNaN and a non-NaN => return the QNaN
     *
     * If we get down to comparing significands and they are the same,
     * return the NaN with the positive sign bit (if any).
     */
    if (aIsSNaN) {
        if (bIsSNaN) {
            return aIsLargerSignificand ? 0 : 1;
        }
        return bIsQNaN ? 1 : 0;
    }
    else if (aIsQNaN) {
        if (bIsSNaN || !bIsQNaN)
            return 0;
        else {
            return aIsLargerSignificand ? 0 : 1;
        }
    } else {
        return 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %r8b, %al
movb %dil, -0x5(%rbp)
movb %sil, -0x6(%rbp)
movb %dl, -0x7(%rbp)
movb %cl, -0x8(%rbp)
movb %al, -0x9(%rbp)
cmpb $0x0, -0x6(%rbp)
je 0x24150
cmpb $0x0, -0x8(%rbp)
je 0x2413a
movzbl -0x9(%rbp), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x2418b
movzbl -0x7(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x2418b
cmpb $0x0, -0x5(%rbp)
je 0x24184
movzbl -0x8(%rbp), %eax
cmpl $0x0, %eax
jne 0x24165
cmpb $0x0, -0x7(%rbp)
jne 0x2416e
movl $0x0, -0x4(%rbp)
jmp 0x2418b
movzbl -0x9(%rbp), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x2418b
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfloat-specialize.h
// Function: pickNaNMulAdd
static int pickNaNMulAdd(flag aIsQNaN, flag aIsSNaN, flag bIsQNaN, flag bIsSNaN,
                         flag cIsQNaN, flag cIsSNaN, flag infzero,
                         float_status *status)
{
    if (aIsSNaN || aIsQNaN) {
        return 0;
    } else if (bIsSNaN || bIsQNaN) {
        return 1;
    } else {
        return 2;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %r8d, -0x1c(%rbp)
movl %ecx, %eax
movl -0x1c(%rbp), %ecx
movl %eax, -0x18(%rbp)
movl %edx, %eax
movl -0x18(%rbp), %edx
movl %eax, -0x14(%rbp)
movl %esi, %eax
movl -0x14(%rbp), %esi
movl %eax, -0x10(%rbp)
movl %edi, %r8d
movl -0x10(%rbp), %edi
movb %r9b, %al
movq 0x18(%rbp), %r9
movb 0x10(%rbp), %r9b
movb %r8b, -0x5(%rbp)
movb %dil, -0x6(%rbp)
movb %sil, -0x7(%rbp)
movb %dl, -0x8(%rbp)
movb %cl, -0x9(%rbp)
movb %al, -0xa(%rbp)
movzbl -0x6(%rbp), %eax
cmpl $0x0, %eax
jne 0x241e8
movzbl -0x5(%rbp), %eax
cmpl $0x0, %eax
je 0x241f1
movl $0x0, -0x4(%rbp)
jmp 0x24213
movzbl -0x8(%rbp), %eax
cmpl $0x0, %eax
jne 0x24203
movzbl -0x7(%rbp), %eax
cmpl $0x0, %eax
je 0x2420c
movl $0x1, -0x4(%rbp)
jmp 0x24213
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/noff/noff.c
// Function: main
int main (int argc, char *argv[])
{
int i, c, ffc;
char *ppos, oline[256], oname[256];
FILE *ifile, *ofile;

if ((argc < 2) || (argv[0] == NULL)) {
	printf ("Usage is: asc file [file...]\n");
	exit (0);  }

for (i = 1; i < argc; i++) {
	strcpy (oname, argv[i]);
        if (ppos = strrchr (oname, '.')) strcpy (ppos, ".new");
            else strcat (oname, ".new");
	ifile = fopen (argv[i], "ra");
	if (ifile == NULL) {
	    printf ("Error opening file: %s\n", argv[i]);
	    exit (0);  }
	ofile = fopen (oname, "wa");
	if (ofile == NULL) {
	    printf ("Error opening file: %s\n", oname);
	    exit (0);  }

	printf ("Processing file %s\n", argv[i]);
	for (ffc = 0; (c = fgetc (ifile)) != EOF; ) {
	    if (c == '\f') ffc++;
	    else fputc (c, ofile);
	    }
	if (ffc) printf ("Form feeds removed: %d\n", ffc);
	fclose (ifile);
	fclose (ofile);
	}
return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jl 0x11e9
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x11fe
leaq 0xe14(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1050
xorl %edi, %edi
callq 0x10b0
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x1387
leaq -0x230(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x1030
leaq -0x230(%rbp), %rdi
movl $0x2e, %esi
callq 0x1060
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1256
movq -0x28(%rbp), %rdi
leaq 0xdd3(%rip), %rsi       # 0x2022
callq 0x1030
jmp 0x1269
leaq -0x230(%rbp), %rdi
leaq 0xdbe(%rip), %rsi       # 0x2022
callq 0x10a0
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0xdab(%rip), %rsi       # 0x2027
callq 0x1090
movq %rax, -0x238(%rbp)
cmpq $0x0, -0x238(%rbp)
jne 0x12b3
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0xd85(%rip), %rdi       # 0x202a
movb $0x0, %al
callq 0x1050
xorl %edi, %edi
callq 0x10b0
leaq -0x230(%rbp), %rdi
leaq 0xd81(%rip), %rsi       # 0x2042
callq 0x1090
movq %rax, -0x240(%rbp)
cmpq $0x0, -0x240(%rbp)
jne 0x12f3
leaq -0x230(%rbp), %rsi
leaq 0xd45(%rip), %rdi       # 0x202a
movb $0x0, %al
callq 0x1050
xorl %edi, %edi
callq 0x10b0
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0xd3f(%rip), %rdi       # 0x2045
movb $0x0, %al
callq 0x1050
movl $0x0, -0x1c(%rbp)
movq -0x238(%rbp), %rdi
callq 0x1070
movl %eax, -0x18(%rbp)
cmpl $-0x1, %eax
je 0x134a
cmpl $0xc, -0x18(%rbp)
jne 0x1339
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1348
movl -0x18(%rbp), %edi
movq -0x240(%rbp), %rsi
callq 0x1080
jmp 0x1314
cmpl $0x0, -0x1c(%rbp)
je 0x1361
movl -0x1c(%rbp), %esi
leaq 0xcff(%rip), %rdi       # 0x2059
movb $0x0, %al
callq 0x1050
movq -0x238(%rbp), %rdi
callq 0x1040
movq -0x240(%rbp), %rdi
callq 0x1040
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1205
xorl %eax, %eax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/vanhauser-thc[P]vulntest/strcpy2.c
// Function: main
int main(int argc, char *argv[]) {
  char buf[16] = "";
  char *in = argv[1], *out = buf;

  if (argc > 1) {
    while (*in != 0) {
      *out++ = *in++;
    }
    *out = 0;
  }
  (void)printf(buf);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1040
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x11c9
jmp 0x1192
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x11c2
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb (%rax), %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
jmp 0x1192
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
leaq -0x20(%rbp), %rdi
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_04/access.c
// Function: main
int main(int argc, char *argv[])
{
	int ret;

	if (argc < 2) {
		fprintf(stderr, "usage: %s <file>\n", argv[0]);
		return -1;
	}

	printf("%s: ", argv[1]);
	ret = access(argv[1], F_OK);
	if (ret < 0) {
		perror("access");
		return -1;
	}
	ret = access(argv[1], R_OK);
	if (ret == 0)
		printf("r");
	ret = access(argv[1], W_OK);
	if (ret == 0)
		printf("w");
	ret = access(argv[1], X_OK);
	if (ret == 0)
		printf("x");
	printf("\n");

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x11b7
movq 0x2e65(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xe60(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x128d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xe50(%rip), %rdi       # 0x2016
movb $0x0, %al
callq 0x1030
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
callq 0x1050
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x11fd
leaq 0xe2f(%rip), %rdi       # 0x201b
callq 0x1060
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x128d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x4, %esi
callq 0x1050
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x1226
leaq 0xe03(%rip), %rdi       # 0x2022
movb $0x0, %al
callq 0x1030
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x2, %esi
callq 0x1050
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x124f
leaq 0xddc(%rip), %rdi       # 0x2024
movb $0x0, %al
callq 0x1030
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x1, %esi
callq 0x1050
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x1278
leaq 0xdb5(%rip), %rdi       # 0x2026
movb $0x0, %al
callq 0x1030
leaq 0xd95(%rip), %rdi       # 0x2014
movb $0x0, %al
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/mmap2.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char tmpfile[] = "/tmp/willitscale.XXXXXX";
	int fd = mkstemp(tmpfile);

	assert(ftruncate(fd, MEMSIZE) == 0);
	unlink(tmpfile);

	while (1) {
		char *c = mmap(NULL, MEMSIZE, PROT_READ|PROT_WRITE,
			       MAP_PRIVATE, fd, 0);
		assert(c != MAP_FAILED);
		munmap(c, MEMSIZE);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x1339(%rip), %rax      # 0x4300
movq %rax, -0x30(%rbp)
movq 0x1336(%rip), %rax      # 0x4308
movq %rax, -0x28(%rbp)
movq 0x1333(%rip), %rax      # 0x4310
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x21b0
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %edi
movl $0x8000000, %esi        # imm = 0x8000000
callq 0x2100
cmpl $0x0, %eax
jne 0x3001
jmp 0x3020
leaq 0x1283(%rip), %rdi      # 0x428b
leaq 0x1298(%rip), %rsi      # 0x42a7
movl $0x10, %edx
leaq 0x129a(%rip), %rcx      # 0x42b5
callq 0x2110
leaq -0x30(%rbp), %rdi
callq 0x2080
movl -0x34(%rbp), %r8d
xorl %eax, %eax
movl %eax, %r9d
movl $0x8000000, %esi        # imm = 0x8000000
movl $0x3, %edx
movl $0x2, %ecx
movq %r9, %rdi
callq 0x20d0
movq %rax, -0x40(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x40(%rbp)
je 0x305c
jmp 0x307b
leaq 0x1285(%rip), %rdi      # 0x42e8
leaq 0x123d(%rip), %rsi      # 0x42a7
movl $0x16, %edx
leaq 0x123f(%rip), %rcx      # 0x42b5
callq 0x2110
movq -0x40(%rbp), %rdi
movl $0x8000000, %esi        # imm = 0x8000000
callq 0x21c0
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x3029
// File: /workspace/github_c_makefile_star2_O0/diaxen[P]fft-garden/./ct_bf.h
// Function: ct_dit_bf2_0
static inline void
ct_dit_bf2_0(unsigned so, unsigned si,
	 complex double * out,
         const complex double * in)
{
  complex double a = in[0];
  complex double b = in[si];
  out[0] = a + b;
  out[so] = a - b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm0
movsd %xmm1, -0x28(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl -0x8(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm0
movsd %xmm1, -0x38(%rbp)
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
movsd -0x38(%rbp), %xmm3
movsd -0x30(%rbp), %xmm2
addsd %xmm3, %xmm1
addsd %xmm2, %xmm0
movq -0x10(%rbp), %rax
movsd %xmm1, (%rax)
movsd %xmm0, 0x8(%rax)
movsd -0x28(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
movsd -0x38(%rbp), %xmm3
movsd -0x30(%rbp), %xmm2
subsd %xmm3, %xmm1
subsd %xmm2, %xmm0
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movsd %xmm1, (%rax)
movsd %xmm0, 0x8(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Sidd0107[P]EXT2-File-System/a3helper.c
// Function: combine_path_and_file
char *combine_path_and_file(char *path, char *file_name){
	int copy_location = 0;
	if(path[strlen(path) - 1] != '/'){
		copy_location = 1;
	}
	char *string = malloc((strlen(path) + strlen(file_name) + 1 + copy_location) * sizeof(char));
	if(!string){
		perror("malloc");
		exit(1);
	}
	memcpy(string, path, strlen(path));
	string[strlen(path)] = '/';
	memcpy(string + strlen(path) + copy_location, file_name, strlen(file_name));
	string[strlen(path) + strlen(file_name) + copy_location] = '\0';
	return string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1060
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x1273
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1060
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1060
movq -0x30(%rbp), %rdi
addq %rax, %rdi
addq $0x1, %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
shlq $0x0, %rdi
callq 0x10f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x12c5
leaq 0x1d6e(%rip), %rdi      # 0x3024
callq 0x1110
movl $0x1, %edi
callq 0x1120
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1060
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq %rax, %rdx
callq 0x10e0
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1060
movq %rax, %rcx
movq -0x60(%rbp), %rax
movb $0x2f, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1060
movq %rax, %rcx
movq -0x58(%rbp), %rax
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1060
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x10e0
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1060
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1060
movq -0x40(%rbp), %rcx
movq %rax, %rdx
movq -0x38(%rbp), %rax
addq %rdx, %rcx
movslq -0x14(%rbp), %rdx
addq %rdx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Sidd0107[P]EXT2-File-System/a3helper.c
// Function: file_exists
int file_exists(char *path, char *inode_base, char *file_name){
	char *string = combine_path_and_file(path, file_name);
	struct basic_fileinfo fileinfo = find_file(string, inode_base);
	free(string);
	return fileinfo.inode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1230
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13f0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1030
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Sidd0107[P]EXT2-File-System/a3helper.c
// Function: find_file
struct basic_fileinfo find_file(char *path, char *inode_base){
	struct basic_fileinfo file_info;
	file_info.type = '\0'; //default
	file_info.inode = 0;
	if(path[0] == '\0'){
		return file_info; //perhaps an error goes here?
	}
	else if (path[0] == '/' && path[1] == '\0'){
		file_info.type = 'd';
		file_info.inode = 2;
		return file_info;
	}
	struct parsed_filename *directory_linked_list = parse_directory(path);
	if(!directory_linked_list){
		return file_info;
	}
	return search_directory(inode_base, 2, directory_linked_list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1421
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1485
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x144f
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x144f
movb $0x64, -0x20(%rbp)
movl $0x2, -0x1c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1485
jmp 0x1451
movq -0x10(%rbp), %rdi
callq 0x1490
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x146f
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1485
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0x2, %esi
callq 0x15c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Sidd0107[P]EXT2-File-System/a3helper.c
// Function: parse_directory
struct parsed_filename *parse_directory(char *path){
	if (path[0] != '/' || path[1] == '\0'){
		return NULL;
	}
	
	int i = 1;
	while (path[i] != '\0' && path[i] != '/'){
		i++;
	}
	
	struct parsed_filename *current_directory_filename = malloc(sizeof(struct parsed_filename));
	
	if(!current_directory_filename){
		perror("malloc for current directory filename");
   	}
	
	current_directory_filename -> file_name = malloc((i)*sizeof(char));
	if(!current_directory_filename -> file_name){
		perror("malloc for string in current directory struct");
		exit(1);
	}
	
	strncpy(current_directory_filename -> file_name, path + 1, i-1);
	current_directory_filename -> file_name[i-1] = '\0';
	
	current_directory_filename -> next = parse_directory(path + i);
	
	return current_directory_filename;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x14b5
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x14c2
movq $0x0, -0x8(%rbp)
jmp 0x15b4
movl $0x1, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
je 0x14f4
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x14fd
jmp 0x1508
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x14c9
movl $0x10, %edi
callq 0x10f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1529
leaq 0x1b07(%rip), %rdi      # 0x302b
callq 0x1110
movslq -0x14(%rbp), %rdi
shlq $0x0, %rdi
callq 0x10f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1560
leaq 0x1b00(%rip), %rdi      # 0x3051
callq 0x1110
movl $0x1, %edi
callq 0x1120
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
movl -0x14(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rdx
callq 0x1040
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
callq 0x1490
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Sidd0107[P]EXT2-File-System/a3helper.c
// Function: type_to_char
char type_to_char(unsigned char type){
	switch(type){
		case 0:
			return '?'; //unknown type
		case 1:
			return 'f'; //regular file
		case 2:
			return 'd'; //directory
		case 3:
			return 'C'; //
		case 4:
			return 'B'; //
		case 5:
			return 'F'; //FIFO
		case 6:
			return 'S'; //
		case 7:
			return 'l'; //soft link
	}
	return '?';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0x7, %rax
ja 0x187c
movq -0x10(%rbp), %rax
leaq 0x17c1(%rip), %rcx      # 0x3004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x3f, -0x1(%rbp)
jmp 0x1880
movb $0x66, -0x1(%rbp)
jmp 0x1880
movb $0x64, -0x1(%rbp)
jmp 0x1880
movb $0x43, -0x1(%rbp)
jmp 0x1880
movb $0x42, -0x1(%rbp)
jmp 0x1880
movb $0x46, -0x1(%rbp)
jmp 0x1880
movb $0x53, -0x1(%rbp)
jmp 0x1880
movb $0x6c, -0x1(%rbp)
jmp 0x1880
movb $0x3f, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Sidd0107[P]EXT2-File-System/a3helper.c
// Function: get_block_from_inode
char *get_block_from_inode(char *inode_base, unsigned int inode_num, unsigned int inode_index){
	struct ext2_inode *current_inode;
	current_inode = get_inode(inode_base, inode_num);
	if (inode_index < 12){
		return get_block(disk, current_inode -> i_block[inode_index], 1024);
	}
	//assuming up to single indirect pointers!
	else{
		unsigned int *indirect_pointer_block = (unsigned int*) get_block(disk, current_inode -> i_block[12], 1024);
		return get_block(disk, indirect_pointer_block[inode_index - 12], 1024);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x17d0
movq %rax, -0x20(%rbp)
cmpl $0xc, -0x18(%rbp)
jae 0x18dd
leaq 0x37f1(%rip), %rax      # 0x50b0
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
movl 0x28(%rax,%rcx,4), %esi
movl $0x400, %edx            # imm = 0x400
callq 0x17f0
movq %rax, -0x8(%rbp)
jmp 0x1923
leaq 0x37cc(%rip), %rax      # 0x50b0
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movl 0x58(%rax), %esi
movl $0x400, %edx            # imm = 0x400
callq 0x17f0
movq %rax, -0x28(%rbp)
leaq 0x37ad(%rip), %rax      # 0x50b0
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0xc, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %esi
movl $0x400, %edx            # imm = 0x400
callq 0x17f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Sidd0107[P]EXT2-File-System/a3helper.c
// Function: find_last_free_bit
int find_last_free_bit(char *bitmap, int num_bits){
	int i;
	for(i = num_bits; i >= 0; i--){
		if (!(*(bitmap+(i/8)) & (1<<(i%8)))){
			return i;
		}
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x1aff
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl -0x1c(%rbp), %eax
movl %edx, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x1af2
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1b06
jmp 0x1af4
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1aa1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Sidd0107[P]EXT2-File-System/a3helper.c
// Function: find_first_free_bit
int find_first_free_bit(char *bitmap, int startbit, int bitmap_num_bits){
	int i;
	for (i = startbit; i < bitmap_num_bits; i++){
		if (!(*(bitmap+(i/8)) & (1<<(i%8)))){
			return i;
		}
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x1bf4
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl -0x20(%rbp), %eax
movl %edx, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x1be7
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1bfb
jmp 0x1be9
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1b94
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Sidd0107[P]EXT2-File-System/a3helper.c
// Function: set_inode
void set_inode(struct ext2_inode *inode, unsigned int inode_num, unsigned int size, unsigned *blocks, int num_blocks, char *block_bitmap, char *inode_bitmap, unsigned int mode){
	set_bit(inode_bitmap, inode_num);
	unsigned int i;
	inode -> i_size = size;
	inode -> i_blocks = (inode -> i_size > 0)? 2*((inode -> i_size - 1)/ 1024) + 2: 0;
	if(inode -> i_blocks >= 25){
		inode -> i_blocks += 2;
	}
	inode -> i_mode = 0x1ff | mode;
	if(num_blocks > 12){
		inode -> i_block[12] = blocks[num_blocks - 1] + 1;
		set_bit(block_bitmap, blocks[num_blocks - 1]);
	}
	for(i = 0; i < ((num_blocks <= 12)? num_blocks : num_blocks - 1); i++){
		set_block_in_inode(inode, blocks[i] + 1, i, block_bitmap);
	}
	inode -> i_links_count = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
movq 0x10(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1b10
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jbe 0x1cdc
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
shrl $0xa, %eax
shll %eax
addl $0x2, %eax
movl %eax, -0x30(%rbp)
jmp 0x1ce3
xorl %eax, %eax
movl %eax, -0x30(%rbp)
jmp 0x1ce3
movl -0x30(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x8(%rbp), %rax
cmpl $0x19, 0x1c(%rax)
jb 0x1d04
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %ecx
addl $0x2, %ecx
movl %ecx, 0x1c(%rax)
movl 0x18(%rbp), %eax
orl $0x1ff, %eax            # imm = 0x1FF
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, (%rax)
cmpl $0xc, -0x1c(%rbp)
jle 0x1d4f
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x58(%rax)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %esi
callq 0x1b10
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x34(%rbp)
cmpl $0xc, -0x1c(%rbp)
jg 0x1d6a
movl -0x1c(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x1d73
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
movl -0x38(%rbp), %ecx
cmpl %ecx, %eax
jae 0x1da5
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl (%rax,%rcx,4), %esi
addl $0x1, %esi
movl -0x2c(%rbp), %edx
movq -0x28(%rbp), %rcx
callq 0x1dc0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1d56
movq -0x8(%rbp), %rax
movw $0x1, 0x1a(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Sidd0107[P]EXT2-File-System/a3helper.c
// Function: set_block_in_inode
void set_block_in_inode(struct ext2_inode* inode, unsigned block_number, unsigned inode_index, char *block_bitmap){
	if(inode_index < 12){
		inode -> i_block[inode_index] = block_number;
	}
	else{
		unsigned int* indirect_pointer_block = (unsigned int *) get_block(disk, inode -> i_block[12], 1024);
		indirect_pointer_block [inode_index - 12] = block_number;
	}
	set_bit(block_bitmap, block_number - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
cmpl $0xc, -0x10(%rbp)
jae 0x1dec
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %edx, 0x28(%rax,%rcx,4)
jmp 0x1e1d
leaq 0x32bd(%rip), %rax      # 0x50b0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x58(%rax), %esi
movl $0x400, %edx            # imm = 0x400
callq 0x17f0
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edx
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
subl $0xc, %ecx
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
subl $0x1, %esi
callq 0x1b10
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Sidd0107[P]EXT2-File-System/a3helper.c
// Function: extract_filename
char *extract_filename(char *filename){
	int i = 0, last_separator = 0;
	while(filename[i] != '\0'){
		if(filename[i] == '/'){
			last_separator = i + 1;
		}
		i++;
	}
	char *file_name = malloc(strlen(filename + last_separator) + 1);
	if(!file_name){
		perror("malloc");
		exit(1);
	}
	memcpy(file_name, filename + last_separator, strlen(filename + last_separator) + 1);
	return file_name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x2100
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x20f5
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x20ca
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rax
addq %rax, %rdi
callq 0x1060
movq %rax, %rdi
addq $0x1, %rdi
callq 0x10f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x213d
leaq 0xef6(%rip), %rdi       # 0x3024
callq 0x1110
movl $0x1, %edi
callq 0x1120
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rax
addq %rax, %rdi
callq 0x1060
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
callq 0x10e0
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Sidd0107[P]EXT2-File-System/a3helper.c
// Function: print_directory_contents
void print_directory_contents(char *inode_base, unsigned int inode_num){
	int i;
	struct ext2_inode *current_inode = get_inode(inode_base, inode_num);
	unsigned int block_num = current_inode->i_block[0];
	unsigned int cur_index_serviced = 0, cur_inode_index = 0;
	char *current_block = get_block(disk, block_num, 1024);
	struct ext2_dir_entry_2 *current = (struct ext2_dir_entry_2 *)current_block;

	while(cur_index_serviced < current_inode -> i_size){
		current = (struct ext2_dir_entry_2 *) (current_block + (cur_index_serviced % 1024));
		for(i = 0; i < current -> name_len; i++){
			printf("%c", current -> name[i]);
		}
		printf("\n");
		cur_index_serviced += current -> rec_len;
		if (cur_index_serviced < current_inode->i_size && cur_index_serviced % 1024 == 0){
			cur_inode_index++;
			current_block = get_block_from_inode(inode_base, inode_num, cur_inode_index);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x17d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
leaq 0x2ee2(%rip), %rax      # 0x50b0
movq (%rax), %rdi
movl -0x1c(%rbp), %esi
movl $0x400, %edx            # imm = 0x400
callq 0x17f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x22a2
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x38(%rbp), %rcx
movzbl 0x6(%rcx), %ecx
cmpl %ecx, %eax
jge 0x224c
movq -0x38(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl 0x8(%rax,%rcx), %esi
leaq 0xe45(%rip), %rdi       # 0x307f
movb $0x0, %al
callq 0x1080
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2217
leaq 0xe83(%rip), %rdi       # 0x30d6
movb $0x0, %al
callq 0x1080
movq -0x38(%rbp), %rax
movzwl 0x4(%rax), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x229d
movl -0x20(%rbp), %eax
andl $0x3ff, %eax            # imm = 0x3FF
cmpl $0x0, %eax
jne 0x229d
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0x1890
movq %rax, -0x30(%rbp)
jmp 0x21ea
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Sidd0107[P]EXT2-File-System/a3helper.c
// Function: free_inode
void free_inode(struct ext2_inode *current_inode, void *disk, char *blockbitmap){
    unsigned int i_size = current_inode->i_size;
    unsigned int blocks = (i_size > 0)? ((i_size-1) / 1024) + 1: 0;
    int block = 0;
    for(block=0; block<blocks; block++){
        //free's indirect blocks
        if(block>=12){
            unsigned int* indirect_pointer_block = (unsigned int *) get_block(disk, current_inode->i_block[12], 1024);
            //indirect_pointer_block [inode_index - 12] = block_number;
            
             unset_bit(blockbitmap, indirect_pointer_block[block - 12] - 1);
             //free(indirect_pointer_block[block - 12]);
            
        }else{
            //free's direct blocks
            unset_bit(blockbitmap, current_inode->i_block[block] - 1);
            //free(current_inode->i_block[block-1]);
        }
        
    }
	if(blocks > 12){
		unset_bit(blockbitmap, current_inode->i_block[12] - 1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jbe 0x22e5
movl -0x1c(%rbp), %eax
subl $0x1, %eax
shrl $0xa, %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x22ec
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0x22ec
movl -0x34(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0x236a
cmpl $0xc, -0x24(%rbp)
jl 0x2345
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x58(%rax), %esi
movl $0x400, %edx            # imm = 0x400
callq 0x17f0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0xc, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %esi
subl $0x1, %esi
callq 0x1c00
jmp 0x235d
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl 0x28(%rax,%rcx,4), %esi
subl $0x1, %esi
callq 0x1c00
jmp 0x235f
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2300
cmpl $0xc, -0x20(%rbp)
jbe 0x2383
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x58(%rax), %esi
subl $0x1, %esi
callq 0x1c00
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vampirefrog[P]x68ksjis/sjis.c
// Function: sjis_strlen
int sjis_strlen(uint8_t *data, int len) {
	int l = 0;
	for(int i = 0; i < len; i++) {
		l++;
		if(data[i] >= 0x80) {
			l++;
			i++;
		}
	}
	return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x152c
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x80, %eax
jl 0x151f
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1521
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x14e9
movl -0x10(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)