// File: /workspace/github_c_makefile_star2_O0/Cyan4973[P]FiniteStateEntropy/programs/commandline.c
// Function: main
int main(int argc, const char** argv)
{
    int   i,
          forceCompress = 1,  /* default action if no argument */
          decode= 0,
          bench = 0;
    int   indexFileNames = 0;
    const char* input_filename = NULL;
    const char* output_filename= NULL;
    char*  tmpFilenameBuffer   = NULL;
    size_t tmpFilenameSize     = 0;
    const char extension[] = FSE_EXTENSION;
    const char* const programName = argv[0];
    FIO_compressor_t compressor = FIO_fse;

    DISPLAY(WELCOME_MESSAGE);
    if (argc<2) badusage(programName);

    for(i = 1; i <= argc; i++) {
        const char* argument = argv[i];

        if(!argument) continue;   /* Protection if argument empty */

        // Decode command (note : aggregated commands are allowed)
        if (argument[0]=='-') {
            // '-' means stdin/stdout
            if (argument[1]==0) {
                if (!input_filename) input_filename=stdinmark;
                else output_filename=stdoutmark;
            }

            while (argument[1]!=0) {
                argument ++;

                switch(argument[0])
                {
                    // Display help
                case 'V': DISPLAY(WELCOME_MESSAGE); return 0;   // Version
                case 'H': usage(programName); return 0;

                    // Decoding
                case 'd': decode=1; bench=0; break;

                    // Benchmark full mode
                case 'b': bench=1; break;

                    // FSE selection (default)
                case 'e':
                    BMK_SetByteCompressor(1);
                    compressor = FIO_fse;
                    break;

                    // HUF selection
                case 'h':
                    BMK_SetByteCompressor(2);
                    compressor = FIO_huf;
                    break;

                    // zlib mode
                case 'z':
                    BMK_SetByteCompressor(3);
                    compressor = FIO_zlibh;
                    break;

                    // Test
                case 't': decode=1; output_filename=nulmark; break;

                    // Overwrite
                case 'f': FIO_overwriteMode(); break;

                    // Verbose mode
                case 'v': displayLevel++; break;

                    // Quiet mode
                case 'q': displayLevel--; break;

                    // keep source file (default anyway, so useless) (for xz/lzma compatibility)
                case 'k': break;

                    // Modify Block Properties
                case 'B':
                    {   unsigned bSize = 0;
                        while ((argument[1] >='0') && (argument[1] <='9'))
                        {
                            unsigned digit = argument[1] - '0';
                            bSize *= 10;
                            bSize += digit;
                            argument++;
                        }
                        if (argument[1]=='K') bSize<<=10, argument++;  /* allows using KB notation */
                        if (argument[1]=='M') bSize<<=20, argument++;
                        if (argument[1]=='B') argument++;
                        BMK_SetBlocksize(bSize);
                    }
                    break;

                    // Modify Stream properties
                case 'S': break;   // to be completed later

                    // Modify Nb Iterations (benchmark only)
                case 'i':
                    if ((argument[1] >='1') && (argument[1] <='9')) {
                        int iters = argument[1] - '0';
                        BMK_SetNbIterations(iters);
                        argument++;
                    }
                    break;

                    // Pause at the end (hidden option)
                case 'p': fse_pause=1; break;

                    /* Change FSE tableLog size (hidden option) */
                case 'M':
                    if ((argument[1] >='1') && (argument[1] <='9')) {
                        int tableLog = argument[1] - '0';
                        BMK_SetTableLog(tableLog);
                        argument++;
                    }
                    break;

                    /* Unrecognised command */
                default : badusage(programName);
                }
            }
            continue;
        }

        /* first provided filename is input */
        if (!input_filename) { input_filename=argument; indexFileNames=i; continue; }

        /* second provided filename is output */
        if (!output_filename) { output_filename=argument; continue; }
    }

    /* No input filename ==> use stdin */
    if(!input_filename) { input_filename=stdinmark; }

    /* Check if input is defined as console; trigger an error in this case */
    if (!strcmp(input_filename, stdinmark) && IS_CONSOLE(stdin) ) badusage(programName);

    /* Check if benchmark is selected */
    if (bench==1) { BMK_benchFiles(argv+indexFileNames, argc-indexFileNames); goto _end; }
    if (bench==3) { BMK_benchCore_Files(argv+indexFileNames, argc-indexFileNames); goto _end; }   /* no longer possible */

    /* No output filename ==> try to select one automatically (when possible) */
    while (!output_filename) {
        if (!IS_CONSOLE(stdout)) { output_filename=stdoutmark; break; }   // Default to stdout whenever possible (i.e. not a console)
        if ((!decode) && !(forceCompress)) {   // auto-determine compression or decompression, based on file extension
            size_t const l = strlen(input_filename);
            if (!strcmp(input_filename+(l-4), FSE_EXTENSION)) decode=1;
        }
        if (!decode) {   /* compression to file */
            size_t const l = strlen(input_filename);
            if (tmpFilenameSize < l+6) tmpFilenameSize = l+6;
            tmpFilenameBuffer = (char*)calloc(1,tmpFilenameSize);
            if (tmpFilenameBuffer==NULL) {
                DISPLAY("Not enough memory, exiting ... \n");
                exit(1);
            }
            strcpy(tmpFilenameBuffer, input_filename);
            strcpy(tmpFilenameBuffer+l, FSE_EXTENSION);
            output_filename = tmpFilenameBuffer;
            DISPLAYLEVEL(2, "Compressed filename will be : %s \n", output_filename);
            break;
        }
        /* decompression to file (automatic name will work only if input filename has correct format extension) */
        {   size_t outl;
            size_t const inl = strlen(input_filename);
            if (tmpFilenameSize < inl+2) tmpFilenameSize = inl+2;
            tmpFilenameBuffer = (char*)calloc(1,tmpFilenameSize);
            strcpy(tmpFilenameBuffer, input_filename);
            outl = inl;
            if (inl>4)
                while ((outl >= inl-4) && (input_filename[outl] ==  extension[outl-inl+4])) tmpFilenameBuffer[outl--]=0;
            if (outl != inl-5) { DISPLAYLEVEL(1, "Cannot determine an output filename\n"); badusage(programName); }
            output_filename = tmpFilenameBuffer;
            DISPLAYLEVEL(2, "Decoding into filename : %s \n", output_filename);
        }
    }   /* (!output_filename) */

    /* No warning message in pure pipe mode (stdin + stdout) */
    if (!strcmp(input_filename, stdinmark) && !strcmp(output_filename,stdoutmark) && (displayLevel==2)) displayLevel=1;

    /* Check if input or output are defined as console; trigger an error in this case */
    if (!strcmp(input_filename, stdinmark)  && IS_CONSOLE(stdin) ) badusage(programName);
    if (!strcmp(output_filename,stdoutmark) && IS_CONSOLE(stdout)) badusage(programName);

    FIO_setDisplayLevel(displayLevel);
    if (decode) FIO_decompressFilename(output_filename, input_filename);
    else {
        FIO_setCompressor(compressor);
        FIO_compressFilename(output_filename, input_filename);
    }

_end:
    if (fse_pause) waitEnter();
    free(tmpFilenameBuffer);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movl 0x22122(%rip), %eax     # 0x256fd
movl %eax, -0x4d(%rbp)
movb 0x2211d(%rip), %al      # 0x25701
movb %al, -0x49(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movl $0x0, -0x5c(%rbp)
movq 0x289f8(%rip), %rax     # 0x2bff8
movq (%rax), %rdi
leaq 0x220f8(%rip), %rsi     # 0x25702
leaq 0x2210e(%rip), %rdx     # 0x2571f
movl $0x40, %ecx
leaq 0x2211d(%rip), %r8      # 0x2573a
leaq 0x22122(%rip), %r9      # 0x25746
movb $0x0, %al
callq 0x1100
cmpl $0x2, -0x8(%rbp)
jge 0x363a
movq -0x58(%rbp), %rdi
callq 0x3df0
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jg 0x39a1
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
jne 0x3669
jmp 0x3993
movq -0x68(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x3969
movq -0x68(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x36a7
cmpq $0x0, -0x30(%rbp)
jne 0x369a
leaq 0x2205c(%rip), %rax     # 0x256f0
movq %rax, -0x30(%rbp)
jmp 0x36a5
leaq 0x22055(%rip), %rax     # 0x256f6
movq %rax, -0x38(%rbp)
jmp 0x36a7
jmp 0x36a9
movq -0x68(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0x3967
movq -0x68(%rbp), %rax
incq %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movsbl (%rax), %eax
addl $-0x42, %eax
movl %eax, %ecx
movq %rcx, -0xa0(%rbp)
subl $0x38, %eax
ja 0x3959
movq -0xa0(%rbp), %rax
leaq 0x21f1d(%rip), %rcx     # 0x2560c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x288f9(%rip), %rax     # 0x2bff8
movq (%rax), %rdi
leaq 0x21ff9(%rip), %rsi     # 0x25702
leaq 0x2200f(%rip), %rdx     # 0x2571f
movl $0x40, %ecx
leaq 0x2201e(%rip), %r8      # 0x2573a
leaq 0x22023(%rip), %r9      # 0x25746
movb $0x0, %al
callq 0x1100
movl $0x0, -0x4(%rbp)
jmp 0x3de2
movq -0x58(%rbp), %rdi
callq 0x3e40
movl $0x0, -0x4(%rbp)
jmp 0x3de2
movl $0x1, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
jmp 0x3962
movl $0x1, -0x20(%rbp)
jmp 0x3962
movl $0x1, %edi
callq 0x1290
movl $0x0, -0x5c(%rbp)
jmp 0x3962
movl $0x2, %edi
callq 0x1290
movl $0x1, -0x5c(%rbp)
jmp 0x3962
movl $0x3, %edi
callq 0x1290
movl $0x2, -0x5c(%rbp)
jmp 0x3962
movl $0x1, -0x1c(%rbp)
leaq 0x21f98(%rip), %rax     # 0x25752
movq %rax, -0x38(%rbp)
jmp 0x3962
callq 0x3fb0
jmp 0x3962
movl 0x28915(%rip), %eax     # 0x2c0e8
addl $0x1, %eax
movl %eax, 0x2890c(%rip)     # 0x2c0e8
jmp 0x3962
movl 0x28901(%rip), %eax     # 0x2c0e8
addl $-0x1, %eax
movl %eax, 0x288f8(%rip)     # 0x2c0e8
jmp 0x3962
jmp 0x3962
movl $0x0, -0x6c(%rbp)
movq -0x68(%rbp), %rax
movsbl 0x1(%rax), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0xa1(%rbp)
jl 0x382a
movq -0x68(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0xa1(%rbp)
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0x3836
jmp 0x3862
movq -0x68(%rbp), %rax
movsbl 0x1(%rax), %eax
subl $0x30, %eax
movl %eax, -0x70(%rbp)
imull $0xa, -0x6c(%rbp), %eax
movl %eax, -0x6c(%rbp)
movl -0x70(%rbp), %eax
addl -0x6c(%rbp), %eax
movl %eax, -0x6c(%rbp)
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
jmp 0x3801
movq -0x68(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x4b, %eax
jne 0x3884
movl -0x6c(%rbp), %eax
shll $0xa, %eax
movl %eax, -0x6c(%rbp)
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x4d, %eax
jne 0x38a6
movl -0x6c(%rbp), %eax
shll $0x14, %eax
movl %eax, -0x6c(%rbp)
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x42, %eax
jne 0x38bf
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
movl -0x6c(%rbp), %edi
callq 0x12b0
jmp 0x3962
jmp 0x3962
movq -0x68(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x31, %eax
jl 0x390d
movq -0x68(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x39, %eax
jg 0x390d
movq -0x68(%rbp), %rax
movsbl 0x1(%rax), %eax
subl $0x30, %eax
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %edi
callq 0x1310
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
jmp 0x3962
movl $0x1, 0x2882b(%rip)     # 0x2c144
jmp 0x3962
movq -0x68(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x31, %eax
jl 0x3957
movq -0x68(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x39, %eax
jg 0x3957
movq -0x68(%rbp), %rax
movsbl 0x1(%rax), %eax
subl $0x30, %eax
movl %eax, -0x78(%rbp)
movl -0x78(%rbp), %edi
callq 0x12f0
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
jmp 0x3962
movq -0x58(%rbp), %rdi
callq 0x3df0
jmp 0x36a9
jmp 0x3993
cmpq $0x0, -0x30(%rbp)
jne 0x3980
movq -0x68(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x3993
cmpq $0x0, -0x38(%rbp)
jne 0x3991
movq -0x68(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x3993
jmp 0x3993
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3641
cmpq $0x0, -0x30(%rbp)
jne 0x39b3
leaq 0x21d41(%rip), %rax     # 0x256f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x21d32(%rip), %rsi     # 0x256f0
callq 0x10e0
cmpl $0x0, %eax
jne 0x39ec
movq 0x28609(%rip), %rax     # 0x2bfd8
movq (%rax), %rdi
callq 0x1130
movl %eax, %edi
callq 0x1050
cmpl $0x0, %eax
je 0x39ec
movq -0x58(%rbp), %rdi
callq 0x3df0
cmpl $0x1, -0x20(%rbp)
jne 0x3a11
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movl -0x8(%rbp), %esi
subl -0x24(%rbp), %esi
callq 0x24d0
jmp 0x3dc4
cmpl $0x3, -0x20(%rbp)
jne 0x3a36
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movl -0x8(%rbp), %esi
subl -0x24(%rbp), %esi
callq 0x2bc0
jmp 0x3dc4
jmp 0x3a38
cmpq $0x0, -0x38(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3a4b
jmp 0x3cde
movq 0x2857e(%rip), %rax     # 0x2bfd0
movq (%rax), %rdi
callq 0x1130
movl %eax, %edi
callq 0x1050
cmpl $0x0, %eax
jne 0x3a76
leaq 0x21c89(%rip), %rax     # 0x256f6
movq %rax, -0x38(%rbp)
jmp 0x3cde
cmpl $0x0, -0x1c(%rbp)
jne 0x3ab8
cmpl $0x0, -0x18(%rbp)
jne 0x3ab8
movq -0x30(%rbp), %rdi
callq 0x1090
movq %rax, -0x80(%rbp)
movq -0x30(%rbp), %rdi
movq -0x80(%rbp), %rax
subq $0x4, %rax
addq %rax, %rdi
leaq 0x21c58(%rip), %rsi     # 0x256fd
callq 0x10e0
cmpl $0x0, %eax
jne 0x3ab6
movl $0x1, -0x1c(%rbp)
jmp 0x3ab8
cmpl $0x0, -0x1c(%rbp)
jne 0x3b86
movq -0x30(%rbp), %rdi
callq 0x1090
movq %rax, -0x88(%rbp)
movq -0x48(%rbp), %rax
movq -0x88(%rbp), %rcx
addq $0x6, %rcx
cmpq %rcx, %rax
jae 0x3af5
movq -0x88(%rbp), %rax
addq $0x6, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
movl $0x1, %edi
callq 0x10d0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x3b30
movq 0x284e3(%rip), %rax     # 0x2bff8
movq (%rax), %rdi
leaq 0x21c3d(%rip), %rsi     # 0x2575c
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1170
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1040
movq -0x40(%rbp), %rdi
addq -0x88(%rbp), %rdi
leaq 0x21bae(%rip), %rsi     # 0x256fd
callq 0x1040
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x2, 0x28585(%rip)     # 0x2c0e8
jl 0x3b81
movq 0x2848c(%rip), %rax     # 0x2bff8
movq (%rax), %rdi
movq -0x38(%rbp), %rdx
leaq 0x21c03(%rip), %rsi     # 0x2577d
movb $0x0, %al
callq 0x1100
jmp 0x3cde
movq -0x30(%rbp), %rdi
callq 0x1090
movq %rax, -0x98(%rbp)
movq -0x48(%rbp), %rax
movq -0x98(%rbp), %rcx
addq $0x2, %rcx
cmpq %rcx, %rax
jae 0x3bb9
movq -0x98(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
movl $0x1, %edi
callq 0x10d0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1040
movq -0x98(%rbp), %rax
movq %rax, -0x90(%rbp)
cmpq $0x4, -0x98(%rbp)
jbe 0x3c6b
jmp 0x3bf2
movq -0x90(%rbp), %rcx
movq -0x98(%rbp), %rdx
subq $0x4, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0xa2(%rbp)
jb 0x3c3e
movq -0x30(%rbp), %rax
movq -0x90(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x90(%rbp), %rcx
subq -0x98(%rbp), %rcx
movsbl -0x49(%rbp,%rcx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0xa2(%rbp)
movb -0xa2(%rbp), %al
testb $0x1, %al
jne 0x3c4a
jmp 0x3c69
movq -0x40(%rbp), %rax
movq -0x90(%rbp), %rcx
movq %rcx, %rdx
addq $-0x1, %rdx
movq %rdx, -0x90(%rbp)
movb $0x0, (%rax,%rcx)
jmp 0x3bf2
jmp 0x3c6b
movq -0x90(%rbp), %rax
movq -0x98(%rbp), %rcx
subq $0x5, %rcx
cmpq %rcx, %rax
je 0x3cac
cmpl $0x1, 0x2845f(%rip)     # 0x2c0e8
jl 0x3ca3
movq 0x28366(%rip), %rax     # 0x2bff8
movq (%rax), %rdi
leaq 0x21b04(%rip), %rsi     # 0x257a0
movb $0x0, %al
callq 0x1100
movq -0x58(%rbp), %rdi
callq 0x3df0
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x2, 0x2842d(%rip)     # 0x2c0e8
jl 0x3cd9
movq 0x28334(%rip), %rax     # 0x2bff8
movq (%rax), %rdi
movq -0x38(%rbp), %rdx
leaq 0x21af3(%rip), %rsi     # 0x257c5
movb $0x0, %al
callq 0x1100
jmp 0x3a38
movq -0x30(%rbp), %rdi
leaq 0x21a07(%rip), %rsi     # 0x256f0
callq 0x10e0
cmpl $0x0, %eax
jne 0x3d1b
movq -0x38(%rbp), %rdi
leaq 0x219f8(%rip), %rsi     # 0x256f6
callq 0x10e0
cmpl $0x0, %eax
jne 0x3d1b
cmpl $0x2, 0x283d9(%rip)     # 0x2c0e8
jne 0x3d1b
movl $0x1, 0x283cd(%rip)     # 0x2c0e8
movq -0x30(%rbp), %rdi
leaq 0x219ca(%rip), %rsi     # 0x256f0
callq 0x10e0
cmpl $0x0, %eax
jne 0x3d54
movq 0x282a1(%rip), %rax     # 0x2bfd8
movq (%rax), %rdi
callq 0x1130
movl %eax, %edi
callq 0x1050
cmpl $0x0, %eax
je 0x3d54
movq -0x58(%rbp), %rdi
callq 0x3df0
movq -0x38(%rbp), %rdi
leaq 0x21997(%rip), %rsi     # 0x256f6
callq 0x10e0
cmpl $0x0, %eax
jne 0x3d8d
movq 0x28260(%rip), %rax     # 0x2bfd0
movq (%rax), %rdi
callq 0x1130
movl %eax, %edi
callq 0x1050
cmpl $0x0, %eax
je 0x3d8d
movq -0x58(%rbp), %rdi
callq 0x3df0
movl 0x28355(%rip), %edi     # 0x2c0e8
callq 0x3fe0
cmpl $0x0, -0x1c(%rbp)
je 0x3dad
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x5110
jmp 0x3dc2
movl -0x5c(%rbp), %edi
callq 0x3fc0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x4040
jmp 0x3dc4
cmpl $0x0, 0x28379(%rip)     # 0x2c144
je 0x3dd2
callq 0x3f80
movq -0x40(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nop