LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::parse_comment_specif(char)
int parse_comment_specif(char c) {
        switch (c) {
        case 'I':
        case 'i':
            return FLAG_IGNORE;
        case 'c':
            return FLAG_COMMENT;
        case 's':
            return FLAG_STRING;
        case 'q':
            return OUTPUT_TEXT;
        case 'S':
            return FLAG_STRING | PARSE_MACROS;
        case 'Q':
            return OUTPUT_TEXT | PARSE_MACROS;
        case 'C':
            return FLAG_COMMENT | PARSE_MACROS;
        default:
            bug("invalid comment/string modifier");
            return 0;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
addl $-0x43, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x30, %eax
ja 0x3713
movq -0x10(%rbp), %rax
leaq 0x7c55(%rip), %rcx      # 0xb320
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x40, -0x4(%rbp)
jmp 0x371f
movl $0x0, -0x4(%rbp)
jmp 0x371f
movl $0x3, -0x4(%rbp)
jmp 0x371f
movl $0x1, -0x4(%rbp)
jmp 0x371f
movl $0x7, -0x4(%rbp)
jmp 0x371f
movl $0x5, -0x4(%rbp)
jmp 0x371f
movl $0x4, -0x4(%rbp)
jmp 0x371f
leaq 0x7feb(%rip), %rdi      # 0xb705
callq 0x35e0
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::process_context()
void process_context() {
            if (C->len == 0) {
                C->buf[0] = '\n';
                C->len++;
            }
            while (!C->eof)
                parse_text();
            free(C->malloced_buf);
            C->malloced_buf = nullptr;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x20(%rax), %rax
cmpl $0x0, 0x10(%rax)
jne 0x37a9
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq (%rcx), %rcx
movb $0xa, (%rcx)
movq 0x20(%rax), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x37ab
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x0, 0x40(%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x37c2
jmp 0x37cd
movq -0x10(%rbp), %rdi
callq 0x3860
jmp 0x37ab
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x2170
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::find_comment_end(char const*, char, char, int, int)
int find_comment_end(const char *endseq, char quote, char warn, int pos,
                int flags) {
            int i;
            char c;

            while (1) {
                c = get_char(pos);
                i = pos;
                if (match_end_sequence(endseq, &i))
                    return pos;
                if (c == 0)
                    bug("input ended while scanning a comment/string");
                if (c == warn) {
                    warn = 0;
                    if (warning_level > 1)
                        warning("possible comment/string termination problem");
                }
                if (c == quote)
                    pos += 2;
                else if ((flags & PARSE_MACROS) && (c == S->user.quotechar))
                    pos += 2;
                else
                    pos++;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %cl, -0x11(%rbp)
movb %al, -0x12(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x6c80
movq -0x30(%rbp), %rdi
movb %al, -0x21(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x3f80
cmpl $0x0, %eax
je 0x3eee
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
movsbl -0x21(%rbp), %eax
cmpl $0x0, %eax
jne 0x3f03
leaq 0x7827(%rip), %rdi      # 0xb725
callq 0x35e0
movsbl -0x21(%rbp), %eax
movsbl -0x12(%rbp), %ecx
cmpl %ecx, %eax
jne 0x3f2e
movq -0x30(%rbp), %rax
movb $0x0, -0x12(%rbp)
movswl 0x18(%rax), %eax
cmpl $0x1, %eax
jle 0x3f2c
leaq 0x782a(%rip), %rdi      # 0xb751
callq 0x6ed0
jmp 0x3f2e
movsbl -0x21(%rbp), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x3f45
movl -0x18(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x18(%rbp)
jmp 0x3f79
movl -0x1c(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x3f6e
movq -0x30(%rbp), %rcx
movsbl -0x21(%rbp), %eax
movq (%rcx), %rcx
movsbl 0x30(%rcx), %ecx
cmpl %ecx, %eax
jne 0x3f6e
movl -0x18(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x18(%rbp)
jmp 0x3f77
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3f79
jmp 0x3eba
nop
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::match_end_sequence(char const*, int*)
int match_end_sequence(const char *s, int *pos) {
            if (*s == 0)
                return 1;
            // if terminator is \n and we're at end of input, let it be...
            if (get_char(*pos) == 0 && s[0] == '\n' && s[1] == 0)
                return 1;
            if (!match_sequence(s, pos))
                return 0;
            return 1;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x3fb1
movl $0x1, -0x4(%rbp)
jmp 0x4010
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
callq 0x6c80
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x3fea
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x3fea
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x3fea
movl $0x1, -0x4(%rbp)
jmp 0x4010
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x6810
cmpl $0x0, %eax
jne 0x4009
movl $0x0, -0x4(%rbp)
jmp 0x4010
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::sendout(char const*, int, int)
void sendout(const char *s, int l, int proc) // only process the quotechar, that's all
        {
            int i;

            if (!commented[iflevel])
                for (i = 0; i < l; i++) {
                    if (proc && (s[i] != 0) && (s[i] == S->user.quotechar)) {
                        i++;
                        if (i == l)
                            return;
                    }
                    if (s[i] != 0)
                        outchar(s[i]);
                }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movslq 0xf0(%rax), %rcx
cmpl $0x0, 0x28(%rax,%rcx,4)
jne 0x40de
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x40dc
cmpl $0x0, -0x18(%rbp)
je 0x40a6
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x40a6
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rdx
movsbl (%rax,%rdx), %eax
movq (%rcx), %rcx
movsbl 0x30(%rcx), %ecx
cmpl %ecx, %eax
jne 0x40a6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x40a4
jmp 0x40de
jmp 0x40a6
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x40cc
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0x6f00
jmp 0x40ce
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4057
jmp 0x40de
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::shift_in(int)
void shift_in(int l) {
            int i;

            if (l <= 1)
                return;
            l--;
            if (l >= C->len)
                C->len = 0;
            else {
                if (C->len - l > 100) { // we want to shrink that buffer
                    C->buf += l;
                    C->bufsize -= l;
                } else
                    for (i = l; i < C->len; i++)
                        C->buf[i - l] = C->buf[i];
                C->len -= l;
                C->eof = (C->buf[0] == 0);
            }
            if (C->len <= 1) {
                if (C->read_stdin)
                    C->eof = feof(stdin);
                else
                    C->eof = 1;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x1, -0xc(%rbp)
jg 0x43e2
jmp 0x450d
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq 0x20(%rcx), %rcx
cmpl 0x10(%rcx), %eax
jl 0x440f
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movl $0x0, 0x10(%rax)
jmp 0x44c2
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x10(%rax), %eax
subl -0xc(%rbp), %eax
cmpl $0x64, %eax
jle 0x444a
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %esi
movq 0x20(%rax), %rcx
movq (%rcx), %rdx
movslq %esi, %rsi
addq %rsi, %rdx
movq %rdx, (%rcx)
movl -0xc(%rbp), %edx
movq 0x20(%rax), %rax
movl 0x14(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x14(%rax)
jmp 0x4492
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
movq 0x20(%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0x4490
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq (%rcx), %rcx
movslq -0x10(%rbp), %rdx
movb (%rcx,%rdx), %dl
movq 0x20(%rax), %rax
movq (%rax), %rax
movl -0x10(%rbp), %ecx
subl -0xc(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4450
jmp 0x4492
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %esi
movq 0x20(%rax), %rcx
movl 0x10(%rcx), %edx
subl %esi, %edx
movl %edx, 0x10(%rcx)
movq 0x20(%rax), %rcx
movq (%rcx), %rcx
movsbl (%rcx), %ecx
cmpl $0x0, %ecx
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
movq 0x20(%rax), %rax
movl %ecx, 0x40(%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x1, 0x10(%rax)
jg 0x450d
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x0, 0x1c(%rax)
je 0x44fc
movq 0xaacb(%rip), %rax      # 0xefb0
movq (%rax), %rdi
callq 0x2240
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movl %ecx, 0x40(%rax)
jmp 0x450b
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movl $0x1, 0x40(%rax)
jmp 0x450d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::get_char(int)
char get_char(int pos) {
            static int lastchar = -666;
            int c;

            if (lastchar == -666 && !strcmp(S->meta.macro_end, "\n"))
                lastchar = '\n';

            if (!C->read_stdin) {
                if (pos >= C->len)
                    return 0;
                else
                    return C->buf[pos];
            }
            extend_buf(pos);
            while (pos >= C->len) {
                do {
                    c = getchar();
                } while (c == 13);
                if (lastchar == '\n')
                    C->lineno++;
                lastchar = c;
                if (c == EOF)
                    c = 0;
                C->buf[C->len++] = (char) c;
            }
            return C->buf[pos];
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0xfffffd66, 0x84e7(%rip) # imm = 0xFFFFFD66
jne 0x6cc9
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x50(%rax), %rdi
leaq 0x44b3(%rip), %rsi      # 0xb168
callq 0x21f0
cmpl $0x0, %eax
jne 0x6cc9
movl $0xa, 0x84bf(%rip)      # 0xf188
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x0, 0x1c(%rax)
jne 0x6d0a
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
movq 0x20(%rcx), %rcx
cmpl 0x10(%rcx), %eax
jl 0x6cf0
movb $0x0, -0x1(%rbp)
jmp 0x6da2
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1(%rbp)
jmp 0x6da2
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xa9b0
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
movq 0x20(%rcx), %rcx
cmpl 0x10(%rcx), %eax
jl 0x6d8d
jmp 0x6d28
callq 0x21d0
movl %eax, -0x18(%rbp)
cmpl $0xd, -0x18(%rbp)
je 0x6d28
cmpl $0xa, 0x844b(%rip)      # 0xf188
jne 0x6d50
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movl -0x18(%rbp), %eax
movl %eax, 0x842f(%rip)      # 0xf188
cmpl $-0x1, -0x18(%rbp)
jne 0x6d66
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
movb %al, %dl
movq 0x20(%rcx), %rax
movq (%rax), %rax
movq 0x20(%rcx), %rsi
movl 0x10(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x10(%rsi)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x6d16
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::identifier_end(int)
int identifier_end(int start) {
            char c;

            c = get_char(start);
            if (c == 0)
                return start;
            if (c == S->user.quotechar) {
                c = get_char(start + 1);
                if (c == 0)
                    return (start + 1);
                if (is_delim(c))
                    return (start + 2);
                start += 2;
                c = get_char(start);
            }
            while (!is_delim(c))
                c = get_char(++start);
            return start;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0x14(%rbp), %esi
callq 0x6c80
movb %al, -0x15(%rbp)
movsbl -0x15(%rbp), %eax
cmpl $0x0, %eax
jne 0x6de6
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6e86
movq -0x20(%rbp), %rcx
movsbl -0x15(%rbp), %eax
movq (%rcx), %rcx
movsbl 0x30(%rcx), %ecx
cmpl %ecx, %eax
jne 0x6e50
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
callq 0x6c80
movb %al, -0x15(%rbp)
movsbl -0x15(%rbp), %eax
cmpl $0x0, %eax
jne 0x6e1f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x6e86
movzbl -0x15(%rbp), %edi
callq 0xa8a0
cmpl $0x0, %eax
je 0x6e38
movl -0x14(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x4(%rbp)
jmp 0x6e86
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
callq 0x6c80
movb %al, -0x15(%rbp)
jmp 0x6e52
movzbl -0x15(%rbp), %edi
callq 0xa8a0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x6e69
jmp 0x6e80
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
callq 0x6c80
movb %al, -0x15(%rbp)
jmp 0x6e52
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::outchar(char)
void outchar(char c) {
            if (C->out->bufsize) {
                if (C->out->len + 1 == C->out->bufsize) {
                    C->out->bufsize = C->out->bufsize * 2;
                    C->out->buf = XX realloc(C->out->buf, C->out->bufsize);
                    if (C->out->buf == nullptr )
                        bug("out of memory");
                }
                C->out->buf[C->out->len++] = c;
            } else {
                if (c != 13) {
                    C->out->output_char(c, C->out->output_char_data);
                }
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x20(%rax), %rax
movq 0x38(%rax), %rax
cmpl $0x0, 0xc(%rax)
je 0x6ff7
movq -0x28(%rbp), %rcx
movq 0x20(%rcx), %rax
movq 0x38(%rax), %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
movq 0x20(%rcx), %rcx
movq 0x38(%rcx), %rcx
cmpl 0xc(%rcx), %eax
jne 0x6fca
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rcx
movq 0x38(%rcx), %rcx
movl 0xc(%rcx), %edx
shll %edx
movq 0x20(%rax), %rcx
movq 0x38(%rcx), %rcx
movl %edx, 0xc(%rcx)
movq 0x20(%rax), %rcx
movq 0x38(%rcx), %rcx
movq (%rcx), %rdi
movq 0x20(%rax), %rax
movq 0x38(%rax), %rax
movslq 0xc(%rax), %rsi
callq 0x2260
movq %rax, %rsi
leaq -0x19(%rbp), %rdi
callq 0x3060
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3730
movq %rax, %rdx
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rcx
movq 0x38(%rcx), %rcx
movq %rdx, (%rcx)
movq 0x20(%rax), %rax
movq 0x38(%rax), %rax
cmpq $0x0, (%rax)
jne 0x6fc8
leaq 0x47c7(%rip), %rdi      # 0xb78a
callq 0x35e0
jmp 0x6fca
movq -0x28(%rbp), %rcx
movb -0x9(%rbp), %dl
movq 0x20(%rcx), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movq 0x20(%rcx), %rcx
movq 0x38(%rcx), %rsi
movl 0x8(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x8(%rsi)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x7026
movsbl -0x9(%rbp), %eax
cmpl $0xd, %eax
je 0x7024
movq -0x28(%rbp), %rdx
movq 0x20(%rdx), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movb -0x9(%rbp), %cl
movq 0x20(%rdx), %rdx
movq 0x38(%rdx), %rdx
movq 0x18(%rdx), %rsi
movsbl %cl, %edi
callq *%rax
jmp 0x7026
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::id_equal(char const*, int, char const*)
int id_equal(const char *b, int l, const char *s) {
        int i;

        if ((int) strlen(s) != l)
            return 0;
        for (i = 0; i < l; i++)
            if (b[i] != s[i])
                return 0;
        return 1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2070
cmpl -0x14(%rbp), %eax
je 0x705a
movl $0x0, -0x4(%rbp)
jmp 0x70a2
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x709b
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x708e
movl $0x0, -0x4(%rbp)
jmp 0x70a2
jmp 0x7090
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x7061
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::push_specs((anonymous namespace)::Specs const*)
void push_specs(const Specs *X) {
            Specs *P;

            P = clone_specs(X);
            P->stack_next = S;
            S = P;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8d80
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq (%rax), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, 0x98(%rcx)
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::delete_comment((anonymous namespace)::Specs*, char*)
void delete_comment(Specs *S, char *start) {
        Comment *p, *q;

        q = nullptr;
        for (p = S->comments; p != nullptr ; p = p->next) {
            if (!strcmp(p->start, start)) {
                if (q == nullptr )
                    S->comments = p->next;
                else
                    q->next = p->next;
                free(p->start);
                free(p->end);
                free(p);
                free(start);
                return;
            } else
                q = p;
        }
        free(start);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x71bb
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x21f0
cmpl $0x0, %eax
jne 0x71a0
cmpq $0x0, -0x20(%rbp)
jne 0x7163
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x90(%rax)
jmp 0x7173
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x2170
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2170
movq -0x18(%rbp), %rdi
callq 0x2170
movq -0x10(%rbp), %rdi
callq 0x2170
jmp 0x71c4
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x71aa
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x7127
movq -0x10(%rbp), %rdi
callq 0x2170
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::comment_or_white(int, int, int)
int comment_or_white(int start, int end, int cmtmode) {
            char c;

            while (start < end) {
                skip_possible_comments(&start, cmtmode, 1);
                if (start < end) {
                    c = get_char(start++);
                    if ((c != ' ') && (c != '\n') && (c != '\t'))
                        return 0;
                }
            }
            return 1;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x76f1
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq -0x14(%rbp), %rsi
movl $0x1, %ecx
callq 0x9230
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x76ef
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
callq 0x6c80
movb %al, -0x1d(%rbp)
movsbl -0x1d(%rbp), %eax
cmpl $0x20, %eax
je 0x76ed
movsbl -0x1d(%rbp), %eax
cmpl $0xa, %eax
je 0x76ed
movsbl -0x1d(%rbp), %eax
cmpl $0x9, %eax
je 0x76ed
movl $0x0, -0x4(%rbp)
jmp 0x76f8
jmp 0x76ef
jmp 0x768d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::whiteout(int*, int*)
int whiteout(int *pos1, int *pos2) // remove whitespace on both sides
        {
            while ((*pos1 < *pos2) && is_white(get_char(*pos1)))
                (*pos1)++;
            while ((*pos1 < *pos2) && is_white(get_char(*pos2 - 1)))
                (*pos2)--;
            return (*pos1 < *pos2);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rdx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, -0x21(%rbp)
jge 0x775f
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x6c80
movsbl %al, %edi
callq 0x9370
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x7768
jmp 0x7775
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x772c
jmp 0x7777
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rdx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, -0x22(%rbp)
jge 0x77ad
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
subl $0x1, %esi
callq 0x6c80
movsbl %al, %edi
callq 0x9370
cmpl $0x0, %eax
setne %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
testb $0x1, %al
jne 0x77b6
jmp 0x77c3
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0x7777
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::find_ident(char const*, int)
int find_ident(const char *b, int l) {
            int i;

            for (i = 0; i < nmacros; i++)
                if (id_equal(b, l, macros[i].username))
                    return i;
            return -1;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x784a
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq 0x8(%rax), %rax
movslq -0x20(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdx
callq 0x7030
cmpl $0x0, %eax
je 0x783d
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7851
jmp 0x783f
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x7802
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::delete_macro(int)
void delete_macro(int i) {
            int j;
            nmacros--;
            free(macros[i].username);
            free(macros[i].macrotext);
            if (macros[i].argnames != nullptr ) {
                for (j = 0; j < macros[i].nnamedargs; j++)
                    free(macros[i].argnames[j]);
                free(macros[i].argnames);
                macros[i].argnames = nullptr;
            }
            free_comments(macros[i].define_specs);
            free(macros[i].define_specs);
            memcpy(macros + i, macros + nmacros, sizeof(Macro));
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x2170
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x2170
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
je 0x7959
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
movq 0x8(%rcx), %rcx
movslq -0xc(%rbp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x1c(%rcx), %eax
jge 0x7922
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2170
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x78d8
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x2170
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rdi
callq 0x93c0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rdi
callq 0x2170
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rdi
movq 0x8(%rax), %rsi
movslq 0x10(%rax), %rax
imulq $0x30, %rax, %rax
addq %rax, %rsi
movl $0x30, %edx
callq 0x2100
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::newmacro(char const*, int, int)
void newmacro(const char *s, int len, int hasspecs) {
            if (nmacros == nalloced) {
                nalloced = 2 * nalloced + 1;
                macros = XX realloc(macros, nalloced * sizeof *macros);
                if (macros == nullptr )
                    bug("out of memory");
            }
            macros[nmacros].username = XX malloc(len + 1);
            strncpy(macros[nmacros].username, s, len + 1);
            macros[nmacros].username[len] = 0;
            macros[nmacros].argnames = nullptr;
            macros[nmacros].nnamedargs = 0;
            macros[nmacros].defined_in_comment = 0;
            if (hasspecs)
                macros[nmacros].define_specs = clone_specs(S);
            else
                macros[nmacros].define_specs = nullptr;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movl 0x10(%rcx), %eax
cmpl 0x14(%rcx), %eax
jne 0x7a4f
movq -0x40(%rbp), %rax
movl 0x14(%rax), %ecx
shll %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movq 0x8(%rax), %rdi
movslq 0x14(%rax), %rax
imulq $0x30, %rax, %rsi
callq 0x2260
movq %rax, %rsi
leaq -0x21(%rbp), %rdi
callq 0x3060
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3090
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x8(%rax)
jne 0x7a4d
leaq 0x3d42(%rip), %rdi      # 0xb78a
callq 0x35e0
jmp 0x7a4f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x21a0
movq %rax, %rsi
leaq -0x31(%rbp), %rdi
callq 0x3060
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3730
movq -0x40(%rbp), %rcx
movq %rax, %rdx
movq 0x8(%rcx), %rax
movslq 0x10(%rcx), %rsi
imulq $0x30, %rsi, %rsi
addq %rsi, %rax
movq %rdx, (%rax)
movq 0x8(%rcx), %rax
movslq 0x10(%rcx), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x20a0
movq -0x40(%rbp), %rcx
movq 0x8(%rcx), %rax
movslq 0x10(%rcx), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rdx
movb $0x0, (%rax,%rdx)
movq 0x8(%rcx), %rax
movslq 0x10(%rcx), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rcx), %rax
movslq 0x10(%rcx), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movl $0x0, 0x1c(%rax)
movq 0x8(%rcx), %rax
movslq 0x10(%rcx), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x28(%rax)
cmpl $0x0, -0x18(%rbp)
je 0x7b42
movq -0x40(%rbp), %rax
movq (%rax), %rdi
callq 0x8d80
movq -0x40(%rbp), %rdx
movq %rax, %rcx
movq 0x8(%rdx), %rax
movslq 0x10(%rdx), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x20(%rax)
jmp 0x7b5d
movq -0x40(%rbp), %rcx
movq 0x8(%rcx), %rax
movslq 0x10(%rcx), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x20(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::remove_comments(int, int, int)
char *remove_comments(int start, int end, int cmtmode) {
            char *s, *t;

            t = s = XX malloc(end - start + 1);
            while (start < end) {
                skip_possible_comments(&start, cmtmode, 1);
                if (start < end) {
                    *t = get_char(start++);
                    if ((*t == S->user.quotechar) && (start < end)) {
                        *(++t) = get_char(start++);
                    }
                    t++;
                }
            }
            *t = 0;
            return s;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x21a0
movq %rax, %rsi
leaq -0x31(%rbp), %rdi
callq 0x3060
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3730
movq %rax, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x7c5b
movq -0x40(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq -0xc(%rbp), %rsi
movl $0x1, %ecx
callq 0x9230
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x7c56
movq -0x40(%rbp), %rdi
movl -0xc(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
callq 0x6c80
movq -0x40(%rbp), %rcx
movb %al, %dl
movq -0x28(%rbp), %rax
movb %dl, (%rax)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
movq (%rcx), %rcx
movsbl 0x30(%rcx), %ecx
cmpl %ecx, %eax
jne 0x7c4a
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x7c4a
movq -0x40(%rbp), %rdi
movl -0xc(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
callq 0x6c80
movb %al, %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, 0x1(%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x7bbf
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::lookup_arg_refs(int)
void lookup_arg_refs(int n) {
            int i, l;
            char *p;

            if (macros[n].argnames != nullptr )
                return; // don't mess with those
            macros[n].nnamedargs = -1;
            l = strlen(S->user.macro_arg_ref);
            for (i = 0, p = macros[n].macrotext; i < macros[n].macrolen; i++, p++) {
                if ((*p != 0) && (*p == S->user.quotechar)) {
                    i++;
                    p++;
                } else if (!strncmp(p, S->user.macro_arg_ref, l))
                    if ((p[l] >= '1') && (p[l] <= '9')) {
                        macros[n].nnamedargs = 0;
                        return;
                    }
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
je 0x7cc2
jmp 0x7de3
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movslq -0xc(%rbp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rcx
movl $0xffffffff, 0x1c(%rcx) # imm = 0xFFFFFFFF
movq (%rax), %rax
movq 0x28(%rax), %rdi
callq 0x2070
movq %rax, %rcx
movq -0x28(%rbp), %rax
movl %ecx, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movl -0x10(%rbp), %eax
movq 0x8(%rcx), %rcx
movslq -0xc(%rbp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x18(%rcx), %eax
jge 0x7de3
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x7d68
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movq (%rcx), %rcx
movsbl 0x30(%rcx), %ecx
cmpl %ecx, %eax
jne 0x7d68
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x7dc7
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movq 0x28(%rax), %rsi
movslq -0x14(%rbp), %rdx
callq 0x2080
cmpl $0x0, %eax
jne 0x7dc5
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x31, %eax
jl 0x7dc3
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jg 0x7dc3
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x1c(%rax)
jmp 0x7de3
jmp 0x7dc5
jmp 0x7dc7
jmp 0x7dc9
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x7d10
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::nowhite_strcmp(char*, char*)
int nowhite_strcmp(char *s, char *t) {
        char *p;

        while (is_white(*s))
            s++;
        while (is_white(*t))
            t++;
        if ((*s == 0) || (*t == 0))
            return strcmp(s, t);
        p = s + strlen(s) - 1;
        while (is_white(*p))
            *(p--) = 0;
        p = t + strlen(t) - 1;
        while (is_white(*p))
            *(p--) = 0;
        return strcmp(s, t);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x9370
cmpl $0x0, %eax
je 0x7e1f
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x7e00
jmp 0x7e21
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x9370
cmpl $0x0, %eax
je 0x7e40
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x7e21
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x7e58
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x7e6d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x21f0
movl %eax, -0x4(%rbp)
jmp 0x7f0d
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2070
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0x9370
cmpl $0x0, %eax
je 0x7eb5
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x0, (%rax)
jmp 0x7e90
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2070
movq %rax, %rcx
movq -0x30(%rbp), %rax
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0x9370
cmpl $0x0, %eax
je 0x7efd
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x0, (%rax)
jmp 0x7ed8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x21f0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::pop_specs()
void pop_specs() {
            Specs *P;

            P = S;
            S = P->stack_next;
            free_comments(P);
            free(P);
            if (S == nullptr )
                bug("#mode restore without #mode save");
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x93c0
movq -0x10(%rbp), %rdi
callq 0x2170
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x8d71
leaq 0x311e(%rip), %rdi      # 0xbe8a
callq 0x35e0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::clone_specs((anonymous namespace)::Specs const*)
Specs *clone_specs(const Specs *Q) {
        Specs *P;
        Comment *x, *y;

        P = XX malloc(sizeof *P);
        if (P == nullptr )
            bug("out of memory.");
        memcpy(P, Q, sizeof(Specs));
        P->stack_next = nullptr;
        if (Q->comments != nullptr )
            P->comments = XX malloc(sizeof *(P->comments));
        for (x = Q->comments, y = P->comments; x != nullptr ;
                x = x->next, y = y->next) {
            memcpy(y, x, sizeof(Comment));
            y->start = my_strdup(x->start);
            y->end = my_strdup(x->end);
            if (x->next != nullptr )
                y->next = XX malloc(sizeof *(y->next));
        }
        return P;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl $0xb8, %edi
callq 0x21a0
movq %rax, %rsi
leaq -0x29(%rbp), %rdi
callq 0x3060
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x30b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8dc6
leaq 0x2e45(%rip), %rdi      # 0xbc06
callq 0x35e0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0xb8, %edx
callq 0x2100
movq -0x10(%rbp), %rax
movq $0x0, 0x98(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x90(%rax)
je 0x8e26
movl $0x28, %edi
callq 0x21a0
movq %rax, %rsi
leaq -0x39(%rbp), %rdi
callq 0x3060
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3680
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8ee7
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x28, %edx
callq 0x2100
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x34e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x34e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x8ec8
movl $0x28, %edi
callq 0x21a0
movq %rax, %rsi
leaq -0x49(%rbp), %rdi
callq 0x3060
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3680
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x8eca
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x8e44
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::iter_identifier_end(int)
int iter_identifier_end(int start) {
            int x;
            while (1) {
                x = identifier_end(start);
                if (x == start)
                    return x;
                start = x;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x6db0
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x9227
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x9207
nop
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::skip_possible_comments(int*, int, int)
void skip_possible_comments(int *pos, int cmtmode, int silentonly) {
            int found;
            Comment *c;

            if (C->in_comment)
                return;
            do {
                found = 0;
                if (get_char(*pos) == 0)
                    return; // EOF
                for (c = S->comments; c != nullptr ; c = c->next)
                    if (!(c->flags[cmtmode] & FLAG_IGNORE))
                        if (!silentonly || (c->flags[cmtmode] == FLAG_COMMENT))
                            if (match_start_sequence(c->start, pos)) {
                                *pos = find_comment_end(c->end, c->quote, c->warn, *pos,
                                        c->flags[cmtmode]);
                                match_end_sequence(c->end, pos);
                                found = 1;
                                break;
                            }
            } while (found);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x20(%rax), %rax
cmpl $0x0, 0x44(%rax)
je 0x925d
jmp 0x9367
jmp 0x925f
movq -0x30(%rbp), %rdi
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x6c80
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x9282
jmp 0x9367
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq 0x90(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x935b
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl 0x14(%rax,%rcx,4), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0x9348
cmpl $0x0, -0x18(%rbp)
je 0x92cc
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpl $0x0, 0x14(%rax,%rcx,4)
jne 0x9346
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0x3c00
cmpl $0x0, %eax
je 0x9344
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x28(%rbp), %rax
movb 0x10(%rax), %cl
movq -0x28(%rbp), %rax
movb 0x11(%rax), %al
movq -0x10(%rbp), %rdx
movl (%rdx), %r8d
movq -0x28(%rbp), %rdx
movslq -0x14(%rbp), %r9
movl 0x14(%rdx,%r9,4), %r9d
movsbl %cl, %edx
movsbl %al, %ecx
callq 0x3e90
movq -0x30(%rbp), %rdi
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0x3f80
movl $0x1, -0x1c(%rbp)
jmp 0x935b
jmp 0x9346
jmp 0x9348
jmp 0x934a
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x9294
jmp 0x935d
cmpl $0x0, -0x1c(%rbp)
jne 0x925f
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::is_white(char)
int is_white(char c) {
        if (c == ' ')
            return 1;
        if (c == '\t')
            return 1;
        if (c == '\n')
            return 1;
        return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0x20, %eax
jne 0x938c
movl $0x1, -0x4(%rbp)
jmp 0x93b7
movsbl -0x5(%rbp), %eax
cmpl $0x9, %eax
jne 0x939e
movl $0x1, -0x4(%rbp)
jmp 0x93b7
movsbl -0x5(%rbp), %eax
cmpl $0xa, %eax
jne 0x93b0
movl $0x1, -0x4(%rbp)
jmp 0x93b7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::free_comments((anonymous namespace)::Specs*)
void free_comments(Specs *Q) {
        Comment *p;

        while (Q && Q->comments != nullptr ) {
            p = Q->comments;
            Q->comments = p->next;
            free(p->start);
            free(p->end);
            free(p);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x11(%rbp)
je 0x93ea
movq -0x8(%rbp), %rax
cmpq $0x0, 0x90(%rax)
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x93f3
jmp 0x9439
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2170
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2170
movq -0x10(%rbp), %rdi
callq 0x2170
jmp 0x93cc
addq $0x20, %rsp
popq %rbp
retq
nop
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::splice_infix(char const*, int, int, char const*, int*, int*)
int splice_infix(const char *buf, int pos1, int pos2, char const* sep, int *spl1, int *spl2) {
        int pos, numpar, l;
        const char *p;

        numpar = 0;
        l = strlen(sep);
        for (pos = pos2 - 1, p = buf + pos; pos >= pos1; pos--, p--) {
            if (*p == ')')
                numpar++;
            if (*p == '(')
                numpar--;
            if (numpar < 0)
                return 0;
            if ((numpar == 0) && (pos2 - pos >= l) && !strncmp(p, sep, l)) {
                *spl1 = pos;
                *spl2 = pos + l;
                return 1;
            }
        }
        return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2070
movl %eax, -0x3c(%rbp)
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jl 0xa5af
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x29, %eax
jne 0xa52a
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x28, %eax
jne 0xa53f
movl -0x38(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
jge 0xa54e
movl $0x0, -0x4(%rbp)
jmp 0xa5b6
cmpl $0x0, -0x38(%rbp)
jne 0xa593
movl -0x18(%rbp), %eax
subl -0x34(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jl 0xa593
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rsi
movslq -0x3c(%rbp), %rdx
callq 0x2080
cmpl $0x0, %eax
jne 0xa593
movl -0x34(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl -0x34(%rbp), %ecx
addl -0x3c(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xa5b6
jmp 0xa595
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x48(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0xa509
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop