LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/travisdowns[P]avx-turbo/test/catch.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Catch::Detail::rangeToString<__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>(__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>)
std::string rangeToString(InputIterator first, Sentinel last) {
            ReusableStringStream rss;
            rss << "{ ";
            if (first != last) {
                rss << ::Catch::Detail::stringify(*first);
                for (++first; first != last; ++first)
                    rss << ", " << ::Catch::Detail::stringify(*first);
            }
            rss << " }";
            return rss.str();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x2310c
movq 0x10(%r12), %rdi
leaq 0x38b42(%rip), %rsi     # 0x4f2eb
callq 0x11520
cmpq %r14, %r15
je 0x1681f
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x16884
movq 0x18(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x114c0
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x11a08
addq $0x4, %r15
leaq 0x38b07(%rip), %r13     # 0x4f2ee
cmpq %r14, %r15
je 0x1681f
movq 0x18(%rsp), %rdi
movq %r13, %rsi
callq 0x11520
movq %r12, %rdi
movq %r15, %rsi
callq 0x16884
movq 0x18(%rsp), %rdi
movq %r12, %rsi
callq 0x114c0
movq %r12, %rdi
callq 0x11a08
addq $0x4, %r15
jmp 0x167e7
movq 0x18(%rsp), %rdi
leaq 0x38ac6(%rip), %rsi     # 0x4f2f1
callq 0x11520
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x17bb4
leaq 0x8(%rsp), %rdi
callq 0x23144
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x16865
jmp 0x16860
jmp 0x16860
jmp 0x16860
movq %rax, %rbx
jmp 0x16872
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x11a08
leaq 0x8(%rsp), %rdi
callq 0x23144
movq %rbx, %rdi
callq 0x118a0
// File: /workspace/github_cpp_makefile_star2_O2/aempirei[P]Chat-Art/palette.cc
// Function: geometry_from_string(geometry&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool geometry_from_string(geometry& g, std::string s) {

	int rgb[3];
	int n;
	int mode;
	int skip;

	auto pos = s.find_first_of("#\r\n");

	if(pos != std::string::npos)
		s.resize(pos);

	if(sscanf(s.c_str(), " mcb %d %d %d color %d %d %d %n",
				&mode, &g.code, &g.base,
				rgb+0, rgb+1, rgb+2,
				&skip)
			== 6)
	{

		// color modes

		g.mode = (geometry::mode_type)mode;

		for(int i = 0; i < 3; i++)
			g.color[i] = (uint8_t)rgb[i];

	} else if(sscanf(s.c_str(), " mcb %d %d %d ratio %d %d size %d %d %n",
				&mode, &g.code, &g.base,
				&g.ratio, &n,
				g.size + 1, g.size + 0,
				&skip)
			== 7)
	{

		// symbol modes

		g.mode = (geometry::mode_type)mode;

	} else if(strspn(s.c_str(), " \t") == strlen(s.c_str())) {

		// blank line

		g.mode = geometry::NOP;
		return false;

	} else {

		// invalid line

		g.mode = geometry::ERR;
		return false;
	}

	// unexpected trailing characters

	if(s[skip] != '\0') {
		g.mode = geometry::ERR;
		return false;
	  }

	// all good

	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1a66(%rip), %rsi      # 0x408d
movq %r14, %rdi
xorl %edx, %edx
callq 0x2080
cmpq $-0x1, %rax
je 0x2642
movq %r14, %rdi
movq %rax, %rsi
callq 0x2170
movq (%r14), %rdi
leaq 0x1c(%rbx), %r15
leaq 0x20(%rbx), %r12
leaq 0x14(%rsp), %r10
leaq 0x18(%rsp), %r11
subq $0x8, %rsp
leaq 0x14(%rsp), %r13
leaq 0x1a2a(%rip), %rsi      # 0x4091
leaq 0x10(%rsp), %rdx
leaq 0x18(%rsp), %r9
movq %r15, %rcx
movq %r12, %r8
xorl %eax, %eax
pushq %r13
pushq %r11
pushq %r10
callq 0x2110
addq $0x20, %rsp
cmpl $0x6, %eax
jne 0x26aa
movl 0x8(%rsp), %eax
movl %eax, 0x18(%rbx)
xorl %eax, %eax
cmpq $0x3, %rax
je 0x26ea
movzbl 0x10(%rsp,%rax,4), %ecx
movl %ecx, 0x8(%rbx,%rax,4)
incq %rax
jmp 0x2696
movq (%r14), %rdi
leaq 0x14(%rbx), %r9
leaq 0x4(%rbx), %r10
leaq 0x1c(%rsp), %r11
leaq 0x19f0(%rip), %rsi      # 0x40b1
leaq 0x8(%rsp), %rdx
movq %r15, %rcx
movq %r12, %r8
xorl %eax, %eax
pushq %r13
pushq %rbx
pushq %r10
pushq %r11
callq 0x2110
addq $0x20, %rsp
cmpl $0x7, %eax
jne 0x26fc
movl 0x8(%rsp), %eax
movl %eax, 0x18(%rbx)
movslq 0xc(%rsp), %rax
movq (%r14), %rcx
cmpb $0x0, (%rcx,%rax)
jne 0x2724
movb $0x1, %al
jmp 0x272a
movq (%r14), %r14
leaq 0x19d3(%rip), %rsi      # 0x40d9
movq %r14, %rdi
callq 0x2050
movq %rax, %r15
movq %r14, %rdi
callq 0x2060
cmpq %rax, %r15
jne 0x2724
andl $0x0, 0x18(%rbx)
jmp 0x2728
orl $-0x1, 0x18(%rbx)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/aempirei[P]Chat-Art/palette.cc
// Function: ms(std::__cxx11::list<long, std::allocator<long>> const&)
long ms(const std::list<long>& xs) {
	long long acc = 0;
	for(auto x : xs)
		acc += x * x;
	return acc;//(long)rint(sqrt(acc));
}

// Assembly:
xorl %eax, %eax
movq %rdi, %rcx
movq (%rcx), %rcx
cmpq %rdi, %rcx
je 0x2752
movq 0x10(%rcx), %rdx
imulq %rdx, %rdx
addq %rdx, %rax
jmp 0x273d
retq
// File: /workspace/github_cpp_makefile_star2_O2/CoinXu[P]reviser-compiler/src/command_line_interface.cpp
// Function: reviser::CommandLineInterface::RegisterGenerator(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, reviser::compiler::CodeGenerator*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void CommandLineInterface::RegisterGenerator(const string& name,
    CodeGenerator* generator, const string& help_text, const string& suffix) {
    GeneratorInfo info;
    info.generator = generator;
    info.help_text = help_text;
    info.output_file_suffix = suffix;
    generators[name] = info;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %r8, %r14
leaq -0x48(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rsi, %rbx
xorl %esi, %esi
movb %sil, (%rax)
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %r15
leaq -0x58(%rbp), %rdi
movb %sil, (%rax)
movq %rdx, -0x38(%rax)
movq %rcx, %rsi
callq 0x35200
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x35200
movq %r15, %rdi
movq %rbx, %rsi
callq 0x38dc0
leaq -0x60(%rbp), %rsi
movq %rax, %rdi
callq 0x38e2a
leaq -0x60(%rbp), %rdi
callq 0x38e62
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x38e62
movq %rbx, %rdi
callq 0x355f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/CoinXu[P]reviser-compiler/src/command_line_interface.cpp
// Function: reviser::CommandLineInterface::ParseArguments(int, char const* const*)
bool CommandLineInterface::ParseArguments(int argc, const char* const argv[]) {
    executable_name = argv[0];

    for (int i = 1; i < argc; i++) {
      string name, value;

      if (ParseArgument(argv[i], &name, &value)) {
        if (i + 1 == argc || argv[i + 1][0] == '-') {
          cerr << "missing value for flag: " << name << endl;
          return false;
        } else {
          i++;
          value = argv[i];
        }
      }

      if (!InterpretArgument(name, value)) {
        return false;
      }
    }

    if (input_files.empty()) {
      cerr << "missing input file." << endl;
      return false;
    }

    if (output_directives.empty()) {
      cerr << "missing output directives." << endl;
      return false;
    }

    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %esi, %r15d
movq %rdx, -0x38(%rbp)
movq (%rdx), %rsi
movq %rdi, -0x30(%rbp)
addq $0xa0, %rdi
callq 0x35650
pushq $0x1
popq %r14
leaq -0x78(%rbp), %r12
leaq -0x58(%rbp), %r13
cmpl %r15d, %r14d
jge 0x3870c
leaq -0x68(%rbp), %rax
movq %rax, -0x78(%rbp)
andq $0x0, -0x70(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
andq $0x0, -0x50(%rbp)
xorl %eax, %eax
movb %al, -0x68(%rbp)
movb %al, -0x48(%rbp)
movslq %r14d, %rax
movq -0x38(%rbp), %rcx
movq (%rcx,%rax,8), %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x3892e
testb %al, %al
je 0x386de
incl %r14d
cmpl %r15d, %r14d
je 0x386ac
movslq %r14d, %rax
movq -0x38(%rbp), %rcx
movq (%rcx,%rax,8), %rsi
cmpb $0x2d, (%rsi)
jne 0x386d6
movq 0x3392d(%rip), %rdi     # 0x6bfe0
leaq 0x1e975(%rip), %rsi     # 0x5702f
callq 0x35320
movq %rax, %rdi
movq %r12, %rsi
callq 0x352e0
movq %rax, %rdi
callq 0x351c0
xorl %ebx, %ebx
jmp 0x386f2
movq %r13, %rdi
callq 0x35650
movq -0x30(%rbp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x38a62
movl %eax, %ebx
incl %r14d
movq %r13, %rdi
callq 0x35180
movq %r12, %rdi
callq 0x35180
testb %bl, %bl
jne 0x3864f
jmp 0x3874a
movq -0x30(%rbp), %rdx
movq 0x48(%rdx), %rax
cmpq 0x50(%rdx), %rax
je 0x3872f
movq 0x30(%rdx), %rcx
movb $0x1, %al
cmpq 0x38(%rdx), %rcx
jne 0x3874c
leaq 0x1e92f(%rip), %rsi     # 0x5705c
jmp 0x38736
leaq 0x1e912(%rip), %rsi     # 0x57048
movq 0x338a3(%rip), %rdi     # 0x6bfe0
callq 0x35320
movq %rax, %rdi
callq 0x351c0
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x35180
leaq -0x78(%rbp), %rdi
callq 0x35180
movq %rbx, %rdi
callq 0x355f0
// File: /workspace/github_cpp_makefile_star2_O2/CoinXu[P]reviser-compiler/src/command_line_interface.cpp
// Function: reviser::CommandLineInterface::MakeSourceCodeInputs(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string CommandLineInterface::MakeSourceCodeInputs(const string& path) {
    const string file_path = io::absolute(path)
      ? path
      : io::join(string(getenv("PWD")), path);

    ifstream f(file_path, ifstream::binary);

    if (!f) {
      cerr << "not found file : " << file_path;
      return "";
    }

    f.seekg(0, f.end);
    int length = f.tellg();
    f.seekg(0, f.beg);
    char* buffer = new char[length];
    f.read(buffer, length);
    f.close();

    string content(buffer, length);
    delete[] buffer;
    return content;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rdx, %r14
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x42697
testb %al, %al
je 0x387a8
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x35470
jmp 0x387e6
leaq 0x1e861(%rip), %rdi     # 0x57010
callq 0x353f0
leaq -0x248(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movq %rax, %rsi
callq 0x35130
leaq -0x40(%rbp), %rdi
leaq -0x248(%rbp), %rsi
movq %r14, %rdx
callq 0x4252c
leaq -0x248(%rbp), %rdi
callq 0x35180
leaq -0x248(%rbp), %rdi
leaq -0x40(%rbp), %rsi
pushq $0x4
popq %rdx
callq 0x35550
movq -0x248(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x228(%rbp,%rax)
je 0x38845
movq 0x337cb(%rip), %rdi     # 0x6bfe0
leaq 0x1ea72(%rip), %rsi     # 0x5728e
callq 0x35320
leaq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0x352e0
leaq 0x2030b(%rip), %rsi     # 0x58b3f
leaq -0x19(%rbp), %rdx
movq %rbx, %rdi
callq 0x35130
jmp 0x388c8
leaq -0x248(%rbp), %rdi
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0x35460
leaq -0x248(%rbp), %rdi
callq 0x355d0
movq %rax, %r14
leaq -0x248(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x35460
movslq %r14d, %r15
testq %r15, %r15
pushq $-0x1
popq %rdi
cmovnsq %r15, %rdi
callq 0x35030
movq %rax, %r14
leaq -0x248(%rbp), %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x35410
leaq -0x248(%rbp), %rdi
callq 0x35080
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdx
addq %r15, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x390a8
movq %r14, %rdi
callq 0x35440
leaq -0x248(%rbp), %rdi
callq 0x350c0
leaq -0x40(%rbp), %rdi
callq 0x35180
movq %rbx, %rax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3890e
jmp 0x3890e
jmp 0x3890e
movq %rax, %rbx
leaq -0x248(%rbp), %rdi
jmp 0x38921
movq %rax, %rbx
jmp 0x38926
jmp 0x3890e
movq %rax, %rbx
jmp 0x3891d
jmp 0x3890e
movq %rax, %rbx
leaq -0x248(%rbp), %rdi
callq 0x350c0
leaq -0x40(%rbp), %rdi
callq 0x35180
movq %rbx, %rdi
callq 0x355f0
// File: /workspace/github_cpp_makefile_star2_O2/CoinXu[P]reviser-compiler/src/command_line_interface.cpp
// Function: reviser::CommandLineInterface::ParseArgument(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
bool CommandLineInterface::ParseArgument(const char* arg, string* name, string* value) {
    bool parsed_value = false;

    if (arg[0] != '-') {
      name->clear();
      parsed_value = false;
      *value = arg;
      return false;
    } else if (arg[1] == '-') {
      const char* equals_post = strchr(arg, '=');
      if (equals_post != NULL) {
        *name = string(arg, equals_post - arg);
        *value = equals_post + 1;
        parsed_value = true;
      } else {
        *name = arg;
      }
    } else {
      if (arg[1] == '\0') {
        name->clear();
        *value = arg;
        parsed_value = true;
      } else {
        *name = string(arg, 2);
        *value = arg + 2;
        parsed_value = !value->empty();
      }
    }

    if (parsed_value) {
      return false;
    }

    // these are only flags that don't take a value
    if (*name == "-h" || *name == "--help" || *name == "--version") {
      return false;
    }

    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
cmpb $0x2d, (%rsi)
jne 0x389aa
movzbl 0x1(%r15), %eax
testl %eax, %eax
je 0x389aa
cmpl $0x2d, %eax
jne 0x389d1
pushq $0x3d
popq %rsi
movq %r15, %rdi
callq 0x35110
testq %rax, %rax
je 0x38a16
movq %rax, %r12
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
leaq -0x48(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x390a8
movq %rbx, %rdi
movq %r13, %rsi
callq 0x35400
movq %r13, %rdi
callq 0x35180
incq %r12
movq %r14, %rdi
movq %r12, %rsi
jmp 0x389bb
andq $0x0, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x35650
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x2(%r15), %r12
leaq -0x48(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x390a8
movq %rbx, %rdi
movq %r13, %rsi
callq 0x35400
movq %r13, %rdi
callq 0x35180
movq %r14, %rdi
movq %r12, %rsi
callq 0x35650
cmpq $0x0, 0x8(%r14)
jne 0x389c0
jmp 0x38a21
movq %rbx, %rdi
movq %r15, %rsi
callq 0x35650
leaq 0x1e64f(%rip), %rsi     # 0x57077
movq %rbx, %rdi
callq 0x38ee6
testb %al, %al
jne 0x389c0
leaq 0x1e63f(%rip), %rsi     # 0x5707a
movq %rbx, %rdi
callq 0x38ee6
testb %al, %al
jne 0x389c0
leaq 0x1e62f(%rip), %rsi     # 0x57081
movq %rbx, %rdi
callq 0x38ee6
xorb $0x1, %al
jmp 0x389c2
nop
// File: /workspace/github_cpp_makefile_star2_O2/CoinXu[P]reviser-compiler/src/command_line_interface.cpp
// Function: reviser::CommandLineInterface::PrintHelpText()
void CommandLineInterface::PrintHelpText() {
    cerr << "Usage: " << executable_name << " [option] DR_FILE\n"
    "  --printer              Specify output type, <fs> will write code to a file on disk\n"
    "                         <terminal> will output to terminal. default <terminal>\n"
    "  --version              Show version info and exit.\n"
    "  -h, --help             Show this text and exit.\n"
    << endl;

    for (GeneratorMap::iterator iter = generators.begin();
      iter != generators.end(); iter++) {
      cerr << "  " << iter->first << "={OUT_DIR}"
        << string(13 - iter->first.size(), ' ')
        << iter->second.help_text << endl;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x33377(%rip), %rdi     # 0x6bfe0
leaq 0x1e4ec(%rip), %rsi     # 0x5715c
callq 0x35320
leaq 0xa0(%rbx), %rsi
movq %rax, %rdi
callq 0x352e0
leaq 0x1e4d9(%rip), %rsi     # 0x57164
movq %rax, %rdi
callq 0x35320
movq %rax, %rdi
callq 0x351c0
movq 0x18(%rbx), %r15
addq $0x8, %rbx
leaq -0x48(%rbp), %r14
pushq $0x20
popq %r12
cmpq %rbx, %r15
je 0x38d36
movq 0x33325(%rip), %rdi     # 0x6bfe0
leaq 0x1ebe9(%rip), %rsi     # 0x578ab
callq 0x35320
leaq 0x20(%r15), %rsi
movq %rax, %rdi
callq 0x352e0
movq %rax, %rdi
leaq 0x1e5a6(%rip), %rsi     # 0x57283
callq 0x35320
movq %rax, %r13
pushq $0xd
popq %rsi
subq 0x28(%r15), %rsi
leaq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq %r14, %rdi
movl %r12d, %edx
callq 0x353c0
movq %r13, %rdi
movq %r14, %rsi
callq 0x352e0
leaq 0x48(%r15), %rsi
movq %rax, %rdi
callq 0x352e0
movq %rax, %rdi
callq 0x351c0
movq %r14, %rdi
callq 0x35180
movq %r15, %rdi
callq 0x35270
movq %rax, %r15
jmp 0x38cab
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x35180
movq %rbx, %rdi
callq 0x355f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/CoinXu[P]reviser-compiler/src/parser.cpp
// Function: reviser::compiler::Parser::Program()
void Parser::Program() {
    Accept(TOKEN_CODE_START);
    generator->descriptor->PushNewContext();

    do {
      if (LookAtType(TOKEN_STRUCT)) {
        Struct* s = ConsumeStruct();
        generator->descriptor->AddGlobalVariableOnce(s->id->text, DECLARE_STRUCT);
        generator->AddStmtStruct(s);
      } else if (LookAtType(TOKEN_ENUM)) {
        Enum* s = ConsumeEnum();
        generator->descriptor->AddGlobalVariableOnce(s->id->text, DECLARE_ENUM);
        generator->AddStmtEnum(s);
      } else {
        Next();
      }
    } while (!Accept(TOKEN_CODE_END));

    generator->descriptor->PopBackContext();
    printer->Print(generator->Generate());
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
pushq $0x8
popq %rsi
callq 0x3ada2
movq 0x8(%r14), %rax
movq 0x50(%rax), %rdi
callq 0x40fe8
leaq -0x88(%rbp), %rbx
pushq $0x9
popq %r13
movq %r14, %rdi
callq 0x3b704
movq %r14, %rdi
cmpl $0x2, %eax
jne 0x3accf
xorl %esi, %esi
callq 0x3ae02
movq %rax, %r12
movq 0x8(%r14), %rax
movq 0x50(%rax), %r15
movq 0x30(%r12), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x35470
movq %r15, %rdi
movq %rbx, %rsi
pushq $0x1
popq %rdx
callq 0x4150e
movq %rbx, %rdi
callq 0x35180
movq 0x8(%r14), %rdi
movq %r12, %rsi
callq 0x3fe9a
jmp 0x3ad2c
callq 0x3b704
movq %r14, %rdi
cmpl $0x3, %eax
jne 0x3ad27
xorl %esi, %esi
callq 0x3b1b8
movq %rax, %r12
movq 0x8(%r14), %rax
movq 0x50(%rax), %r15
movq 0x30(%r12), %rsi
addq $0x8, %rsi
leaq -0x68(%rbp), %rdi
callq 0x35470
movq %r15, %rdi
leaq -0x68(%rbp), %r15
movq %r15, %rsi
xorl %edx, %edx
callq 0x4150e
movq %r15, %rdi
callq 0x35180
movq 0x8(%r14), %rdi
movq %r12, %rsi
callq 0x3fe4a
jmp 0x3ad2c
callq 0x3b472
movq %r14, %rdi
movl %r13d, %esi
callq 0x3ada2
testb %al, %al
je 0x3ac78
movq 0x8(%r14), %rax
movq 0x50(%rax), %rdi
callq 0x41040
movq 0x8(%r14), %rsi
movq 0x50(%r14), %r14
movq (%rsi), %rax
leaq -0x48(%rbp), %rbx
movq %rbx, %rdi
callq *0x10(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
leaq -0x48(%rbp), %rdi
callq 0x35180
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3ad8e
movq %rax, %r14
movq %r15, %rbx
jmp 0x3ad91
movq %rax, %r14
movq %rbx, %rdi
callq 0x35180
movq %r14, %rdi
callq 0x355f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/CoinXu[P]reviser-compiler/src/parser.cpp
// Function: reviser::compiler::Parser::Accept(reviser::compiler::TokenType)
bool Parser::Accept(TokenType type) {
    token = tokenizer->Current();
    if (token.type == type) {
      tokenizer->Next();
      return true;
    }
    return false;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x3da3c
leaq 0x10(%r14), %rdi
movq %rax, %rsi
callq 0x3ccc2
movl 0x10(%r14), %r15d
cmpl %ebx, %r15d
jne 0x3add6
movq (%r14), %rdi
callq 0x3dc86
cmpl %ebx, %r15d
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/CoinXu[P]reviser-compiler/src/parser.cpp
// Function: reviser::compiler::Parser::CloneToken(reviser::compiler::Token const&)
Token* Parser::CloneToken(const Token& t) {
    return new Token {
      t.type,
      t.text,
      t.start_line,
      t.end_line,
      t.column_start,
      t.column_start,
      t.pos_start,
      t.pos_end
    };
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
pushq $0x40
popq %rdi
callq 0x35330
movq %rax, %rbx
movl (%r14), %eax
movl %eax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x8(%r14), %rsi
callq 0x35470
movl 0x28(%r14), %eax
movl %eax, 0x28(%rbx)
movl 0x2c(%r14), %eax
movl %eax, 0x2c(%rbx)
movl 0x30(%r14), %eax
movl %eax, 0x30(%rbx)
movl %eax, 0x34(%rbx)
movl 0x38(%r14), %eax
movl %eax, 0x38(%rbx)
movl 0x3c(%r14), %eax
movl %eax, 0x3c(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x35310
movq %r14, %rdi
callq 0x355f0
// File: /workspace/github_cpp_makefile_star2_O2/CoinXu[P]reviser-compiler/src/parser.cpp
// Function: reviser::compiler::Parser::RuntimeError(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, reviser::compiler::Token*)
void Parser::RuntimeError(string msg = "syntax error", Token* t = nullptr) {
    if (!t) {
      t = &token;
    }

    message.SetLine(t->start_line);
    message.SetColumn(t->column_start);
    message.Runtime(msg + ": " + t->text);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
testq %rdx, %rdx
cmoveq %rax, %r14
movl 0x28(%r14), %eax
movl %eax, 0x58(%rdi)
movl 0x30(%r14), %eax
movl %eax, 0x5c(%rdi)
leaq 0x1bd82(%rip), %rdx     # 0x5729d
leaq -0x58(%rbp), %r15
movq %r15, %rdi
callq 0x3ccf9
addq $0x8, %r14
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x38ef6
addq $0x58, %rbx
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x3a8c2
leaq -0x38(%rbp), %rdi
callq 0x35180
leaq -0x58(%rbp), %rdi
callq 0x35180
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x35180
jmp 0x3b578
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x35180
movq %rbx, %rdi
callq 0x355f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/CoinXu[P]reviser-compiler/src/parser.cpp
// Function: reviser::compiler::Parser::Expect(reviser::compiler::TokenType)
void Parser::Expect(TokenType type) {
    if (!Accept(type)) {
      RuntimeError(
        "expect token [" + TokenTypeNameMap[type] + "] but receive ["
        + TokenTypeNameMap[token.type] + "]"
      );
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movl %esi, -0x14(%rbp)
callq 0x3ada2
testb %al, %al
jne 0x3b650
leaq 0x3131e(%rip), %rdi     # 0x6c8d0
leaq -0x14(%rbp), %rsi
callq 0x3cd32
leaq 0x1bf62(%rip), %rsi     # 0x57524
leaq -0x98(%rbp), %r14
movq %r14, %rdi
movq %rax, %rdx
callq 0x3aa1e
leaq 0x1bf58(%rip), %rdx     # 0x57533
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x38f1f
leaq 0x10(%rbx), %rsi
leaq 0x312de(%rip), %rdi     # 0x6c8d0
callq 0x3cd32
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0x38ef6
leaq 0x1d404(%rip), %rdx     # 0x58a12
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x38f1f
leaq -0x78(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3b4e8
leaq -0x78(%rbp), %rdi
callq 0x35180
leaq -0x58(%rbp), %rdi
callq 0x35180
leaq -0x38(%rbp), %rdi
callq 0x35180
leaq -0x98(%rbp), %rdi
callq 0x35180
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x35180
jmp 0x3b66d
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x35180
jmp 0x3b680
movq %rax, %rbx
jmp 0x3b689
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x35180
leaq -0x98(%rbp), %rdi
callq 0x35180
movq %rbx, %rdi
callq 0x355f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/CoinXu[P]reviser-compiler/src/parser.cpp
// Function: reviser::compiler::Parser::ConsumeStructProperty()
StructProperty* Parser::ConsumeStructProperty() {
    vector<Decorater*> v;
    if (Accept(TOKEN_DECORATER)) {
      do {
        v.push_back(ConsumeDecorater());
      } while (Accept(TOKEN_DECORATER));
    }

    Declare* declare = ConsumeDeclare();
    StructProperty* property = new StructProperty(declare);

    Expect(TOKEN_SEMICOLON);

    for (Decorater* d : v) {
      property->decoraters.push_back(d);
    }
    return property;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
andq $0x0, -0x40(%rbp)
pushq $0x1
popq %rsi
callq 0x3ada2
testb %al, %al
je 0x3b7aa
leaq -0x50(%rbp), %r14
leaq -0x30(%rbp), %r15
pushq $0x1
popq %r12
movq %rbx, %rdi
callq 0x3b84e
movq %rax, -0x30(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3d114
movq %rbx, %rdi
movl %r12d, %esi
callq 0x3ada2
testb %al, %al
jne 0x3b784
movq %rbx, %rdi
callq 0x3b8e0
movq %rax, %r15
pushq $0x50
popq %rdi
callq 0x35330
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x3f51c
pushq $0x3b
popq %rsi
movq %rbx, %rdi
callq 0x3b58a
movq -0x50(%rbp), %r12
movq -0x48(%rbp), %r13
movq %r14, %rbx
addq $0x30, %rbx
leaq -0x30(%rbp), %r15
cmpq %r13, %r12
je 0x3b807
movq (%r12), %rax
movq %rax, -0x30(%rbp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3cd84
addq $0x8, %r12
jmp 0x3b7e9
leaq -0x50(%rbp), %rdi
callq 0x3d100
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x35310
jmp 0x3b83c
jmp 0x3b839
jmp 0x3b839
jmp 0x3b839
jmp 0x3b839
jmp 0x3b839
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3d100
movq %rbx, %rdi
callq 0x355f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/CoinXu[P]reviser-compiler/src/parser.cpp
// Function: reviser::compiler::Parser::ConsumeDataTypeArrayDeclare(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Declare* Parser::ConsumeDataTypeArrayDeclare(string type_string) {
    Expect(TOKEN_RIGHT_BRACKET);

    if (DataTypeValue.find(type_string) == DataTypeValue.end()) {
      RuntimeError("unknow data type: " + type_string);
    }

    Expect(TOKEN_ID);
    const Token id = token;

    Expect(TOKEN_ASSIGN);
    Expect(TOKEN_LEFT_BRACKET);
    // TODO support initial values
    Expect(TOKEN_RIGHT_BRACKET);

    DataType type = DataTypeValue.at(type_string);

    generator->descriptor->include_type_array = true;
    generator->descriptor->AddDataTypesOnce(type);

    RightValue* rv = new RightValue(type, CloneToken(token), true);
    return new Declare(type, CloneToken(id), rv, true);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x5d
popq %rsi
callq 0x3b58a
leaq 0x30d02(%rip), %r15     # 0x6c960
movq %r15, %rdi
movq %r14, %rsi
callq 0x3d34c
addq $0x8, %r15
cmpq %r15, %rax
jne 0x3bc9e
leaq 0x1b94b(%rip), %rsi     # 0x575c4
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x3aa1e
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3b4e8
leaq -0x38(%rbp), %rdi
callq 0x35180
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x3b58a
leaq 0x10(%rbx), %r15
leaq -0x78(%rbp), %rdi
movq %r15, %rsi
callq 0x3cc8e
pushq $0x3d
popq %rsi
movq %rbx, %rdi
callq 0x3b58a
pushq $0x5b
popq %rsi
movq %rbx, %rdi
callq 0x3b58a
pushq $0x5d
popq %rsi
movq %rbx, %rdi
callq 0x3b58a
leaq 0x30c7f(%rip), %rdi     # 0x6c960
movq %r14, %rsi
callq 0x3cda8
movl (%rax), %r14d
movq 0x8(%rbx), %rax
movq 0x50(%rax), %rdi
movb $0x1, 0x60(%rdi)
movl %r14d, %esi
callq 0x415b6
pushq $0x58
popq %rdi
callq 0x35330
movq %rax, %rbx
movq %r15, %rsi
callq 0x3b480
pushq $0x1
popq %rcx
movq %rbx, %rdi
movl %r14d, %esi
movq %rax, %rdx
callq 0x3f210
pushq $0x20
popq %rdi
callq 0x35330
movq %rax, %r15
leaq -0x78(%rbp), %rsi
callq 0x3b480
pushq $0x1
popq %r8
movq %r15, %rdi
movl %r14d, %esi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x3f2d2
leaq -0x70(%rbp), %rdi
callq 0x35180
movq %r15, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x38(%rbp), %rdi
jmp 0x3bd8d
movq %rax, %r14
movq %r15, %rdi
jmp 0x3bd7d
jmp 0x3bd86
movq %rax, %r14
movq %rbx, %rdi
callq 0x35310
jmp 0x3bd89
jmp 0x3bd86
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x35180
movq %r14, %rdi
callq 0x355f0
// File: /workspace/github_cpp_makefile_star2_O2/CoinXu[P]reviser-compiler/src/parser.cpp
// Function: reviser::compiler::Parser::ConsumeStructArrayDeclare(reviser::compiler::Token const&)
Declare* Parser::ConsumeStructArrayDeclare(const Token& struct_id) {
    Expect(TOKEN_RIGHT_BRACKET);
    Expect(TOKEN_ID);

    Token* sid = CloneToken(struct_id);
    Token* id = CloneToken(token);
    StructValue* sv;

    if (Accept(TOKEN_ASSIGN)) {
      if (Accept(TOKEN_LEFT_BRACKET)) {
        Expect(TOKEN_RIGHT_BRACKET);
        // TODO make TYPE_EMPTY_ARRAY type for data type
        sv = new StructValue(sid, CloneToken(token));
      } else {
        delete sid;
        delete id;
        RuntimeError("unknow struct array default value");
      }
    } else {
      sv = new StructValue(sid, nullptr);
    }

    generator->descriptor->include_struct_array = true;
    RightValue* rv = new RightValue(sv, true);
    return new Declare(TYPE_STRUCT, id, sid, rv, true);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r15
pushq $0x5d
popq %rsi
callq 0x3b58a
pushq $0x4
popq %rsi
movq %r15, %rdi
callq 0x3b58a
movq %rbx, %rsi
callq 0x3b480
movq %rax, %rbx
leaq 0x10(%r15), %r13
movq %r13, %rsi
callq 0x3b480
movq %rax, %r14
pushq $0x3d
popq %rsi
movq %r15, %rdi
callq 0x3ada2
testb %al, %al
je 0x3c3ec
pushq $0x5b
popq %rsi
movq %r15, %rdi
callq 0x3ada2
testb %al, %al
je 0x3c406
pushq $0x5d
popq %rsi
movq %r15, %rdi
callq 0x3b58a
pushq $0x10
popq %rdi
callq 0x35330
movq %rax, %r12
movq %r13, %rsi
callq 0x3b480
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3f296
jmp 0x3c459
pushq $0x10
popq %rdi
callq 0x35330
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3f296
jmp 0x3c459
movq %rbx, %rdi
addq $0x8, %rdi
callq 0x35180
movq %rbx, %rdi
callq 0x35310
movq %r14, %rdi
addq $0x8, %rdi
callq 0x35180
movq %r14, %rdi
callq 0x35310
leaq 0x1b301(%rip), %rsi     # 0x57736
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x35130
leaq -0x50(%rbp), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x3b4e8
leaq -0x50(%rbp), %rdi
callq 0x35180
movq 0x8(%r15), %rax
movq 0x50(%rax), %rax
movb $0x1, 0x61(%rax)
pushq $0x58
popq %rdi
callq 0x35330
movq %rax, %r15
pushq $0x1
popq %rdx
movq %rax, %rdi
movq %r12, %rsi
callq 0x3f22e
pushq $0x20
popq %rdi
callq 0x35330
movq %rax, %r12
pushq $0xa
popq %rsi
pushq $0x1
popq %r9
movq %rax, %rdi
movq %r14, %rdx
movq %rbx, %rcx
movq %r15, %r8
callq 0x3f2ec
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x35180
jmp 0x3c4dd
movq %rax, %rbx
jmp 0x3c4dd
jmp 0x3c4ca
jmp 0x3c4ca
movq %rax, %rbx
movq %r12, %rdi
jmp 0x3c4d8
movq %rax, %rbx
movq %r15, %rdi
callq 0x35310
movq %rbx, %rdi
callq 0x355f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/CoinXu[P]reviser-compiler/src/parser.cpp
// Function: reviser::compiler::Parser::ConsumeEnumArrayDeclare(reviser::compiler::Token const&)
Declare* Parser::ConsumeEnumArrayDeclare(const Token& enum_id) {
    Expect(TOKEN_RIGHT_BRACKET);
    Expect(TOKEN_ID);

    Token* eid = CloneToken(enum_id);
    Token* id = CloneToken(token);

    generator->descriptor->include_enum_array = true;
    return nullptr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x5d
popq %rsi
callq 0x3b58a
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x3b58a
movq %rbx, %rsi
callq 0x3b480
leaq 0x10(%r14), %rsi
callq 0x3b480
movq 0x8(%r14), %rax
movq 0x50(%rax), %rax
movb $0x1, 0x62(%rax)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/CoinXu[P]reviser-compiler/src/parser.cpp
// Function: reviser::compiler::Parser::ConsumeEnumProperty()
EnumProperty* Parser::ConsumeEnumProperty() {
    Expect(TOKEN_ID);
    Token* id = CloneToken(token);

    if (Accept(TOKEN_ASSIGN)) {
      Expect(TOKEN_DIGIT);
      RightValue* value = new RightValue(TYPE_INT32, CloneToken(token));
      EnumProperty* property = new EnumProperty(id, value);
      return property;
    }

    EnumProperty* property = new EnumProperty(id);
    return property;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x4
popq %rsi
callq 0x3b58a
leaq 0x10(%rbx), %r15
movq %r15, %rsi
callq 0x3b480
movq %rax, %r14
pushq $0x3d
popq %rsi
movq %rbx, %rdi
callq 0x3ada2
testb %al, %al
je 0x3cc4d
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x3b58a
pushq $0x58
popq %rdi
callq 0x35330
movq %rax, %rbx
movq %r15, %rsi
callq 0x3b480
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x3f210
pushq $0x40
popq %rdi
callq 0x35330
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3f368
movq %r15, %rbx
jmp 0x3cc63
pushq $0x40
popq %rdi
callq 0x35330
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x3f39e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r15, %rbx
jmp 0x3cc7e
jmp 0x3cc7b
movq %rax, %r14
movq %rbx, %rdi
callq 0x35310
movq %r14, %rdi
callq 0x355f0
// File: /workspace/github_cpp_makefile_star2_O2/CoinXu[P]reviser-compiler/src/tokenizer.cpp
// Function: reviser::compiler::Tokenizer::NextChar()
void Tokenizer::NextChar() {
  if (peek == '\n') {
    line++;
    column = 1;
  } else if (peek == '\t') {
    column += CTabWidth - column % CTabWidth;
  } else {
    column++;
  }

  if (pos < input.size()) {
    peek = input.at(pos);
    pos++;
    return;
  }

  peek = EOF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzbl 0xf8(%rdi), %eax
cmpl $0x9, %eax
je 0x3d870
cmpl $0xa, %eax
jne 0x3d88e
incl 0x100(%rbx)
movl $0x1, 0x104(%rbx)
jmp 0x3d894
movl 0x104(%rbx), %ecx
pushq $0x8
popq %rsi
movl %ecx, %eax
cltd
idivl %esi
negl %edx
leal (%rcx,%rdx), %eax
addl $0x8, %eax
movl %eax, 0x104(%rbx)
jmp 0x3d894
incl 0x104(%rbx)
movslq 0xfc(%rbx), %rsi
movb $-0x1, %al
cmpq %rsi, 0x8(%rbx)
jbe 0x3d8b3
movq %rbx, %rdi
callq 0x35660
movb (%rax), %al
incl 0xfc(%rbx)
movb %al, 0xf8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/CoinXu[P]reviser-compiler/src/tokenizer.cpp
// Function: reviser::compiler::Tokenizer::TryConsume(char)
bool Tokenizer::TryConsume(char c) {
  if (peek == c) {
    NextChar();
    return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movb 0xf8(%rdi), %r14b
cmpb %bl, %r14b
jne 0x3d924
callq 0x3d844
cmpb %bl, %r14b
sete %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/CoinXu[P]reviser-compiler/src/tokenizer.cpp
// Function: reviser::compiler::Tokenizer::ConsumeComment()
void Tokenizer::ConsumeComment() {
  while (InCharacters<CharDivide>()) {
    NextChar();

    if (InCharacters<CharDivide>()) {
      // line comment
      NextChar();
      if (peek != EOF) {
        TryConsumeCharacters<NewLine>();
      }
    } else if (InCharacters<CharAsterisk>()) {
      // block comment
      NextChar();
      while(true) {
        TryConsumeCharacters<CharAsterisk>();
        NextChar();
        if (InCharacters<CharDivide>() || peek == EOF) {
          break;
        }
      }
    }

    NextChar();
    ConsumeCharacters<Whitespace>();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x2f, 0xf8(%rbx)
jne 0x3da03
movq %rbx, %rdi
callq 0x3d844
movzbl 0xf8(%rbx), %eax
cmpl $0x2a, %eax
je 0x3d9c6
cmpl $0x2f, %eax
jne 0x3d9f1
movq %rbx, %rdi
callq 0x3d844
cmpb $-0x1, 0xf8(%rbx)
je 0x3d9f1
movq %rbx, %rdi
callq 0x3e404
jmp 0x3d9f1
movq %rbx, %rdi
callq 0x3d844
movq %rbx, %rdi
callq 0x3e428
movq %rbx, %rdi
callq 0x3d844
movzbl 0xf8(%rbx), %eax
cmpl $0xff, %eax
je 0x3d9f1
cmpl $0x2f, %eax
jne 0x3d9ce
movq %rbx, %rdi
callq 0x3d844
movq %rbx, %rdi
callq 0x3e44c
jmp 0x3d989
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/CoinXu[P]reviser-compiler/src/tokenizer.cpp
// Function: reviser::compiler::Tokenizer::ConsumeNumber()
void Tokenizer::ConsumeNumber() {
  // 整数位
  ConsumeCharacters<CharDigit>();

  // 小数位
  if (TryConsume(TOKEN_CONNECTION)) {
    ConsumeCharacters<CharDigit>();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3e482
pushq $0x2e
popq %rsi
movq %rbx, %rdi
callq 0x3d90a
testb %al, %al
je 0x3da35
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3e482
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/CoinXu[P]reviser-compiler/src/tokenizer.cpp
// Function: reviser::compiler::Tokenizer::Printf(reviser::compiler::Token const*)
void Tokenizer::Printf(const Token* token) {
  message.SetLine(token->start_line);
  message.SetColumn(token->column_start);
  message.Debug("-------------------------------------------");
  message.Debug("token.type: " + to_string(token->type));
  message.Debug("token.name: " + TokenTypeNameMap.at(token->type));
  message.Debug("token.text: " + token->text);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x28(%rsi), %eax
movl %eax, 0x50(%rdi)
movl 0x30(%rsi), %eax
movl %eax, 0x54(%rdi)
leaq 0x19db9(%rip), %rsi     # 0x57836
leaq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x35130
addq $0x50, %rbx
leaq -0x78(%rbp), %rsi
movq %rbx, %rdi
callq 0x3a7fc
leaq -0x78(%rbp), %rdi
callq 0x35180
movl (%r14), %esi
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x3aa94
leaq 0x19da9(%rip), %rsi     # 0x57862
leaq -0x58(%rbp), %rdi
movq %r15, %rdx
callq 0x3e4a8
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x3a7fc
leaq -0x58(%rbp), %rdi
callq 0x35180
leaq -0x38(%rbp), %rdi
callq 0x35180
leaq 0x2ede6(%rip), %rdi     # 0x6c8d0
movq %r14, %rsi
callq 0x3e4d6
leaq 0x19d76(%rip), %rsi     # 0x5786f
leaq -0xb8(%rbp), %r15
movq %r15, %rdi
movq %rax, %rdx
callq 0x3aa1e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3a7fc
leaq -0xb8(%rbp), %rdi
callq 0x35180
addq $0x8, %r14
leaq 0x19d4f(%rip), %rsi     # 0x5787c
leaq -0x98(%rbp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x3aa1e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3a7fc
leaq -0x98(%rbp), %rdi
callq 0x35180
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
jmp 0x3db9a
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
jmp 0x3db9a
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x35180
jmp 0x3db8d
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
jmp 0x3db9a
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x35180
movq %rbx, %rdi
callq 0x355f0
movq %rax, %rbx
jmp 0x3db9f
// File: /workspace/github_cpp_makefile_star2_O2/CoinXu[P]reviser-compiler/src/tokenizer.cpp
// Function: reviser::compiler::Tokenizer::PrintPoint(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Tokenizer::PrintPoint(const string mark) {
  message.SetLine(line);
  message.SetColumn(column);
  message.Debug("pos: " + to_string(pos));
  message.Debug("char: " + to_string(peek));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq 0x100(%rdi), %rax
movq %rax, 0x50(%rdi)
movl 0xfc(%rdi), %esi
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x3aa94
leaq 0x19cab(%rip), %rsi     # 0x57889
leaq -0x70(%rbp), %rdi
movq %r14, %rdx
callq 0x3e4a8
leaq 0x50(%rbx), %r14
leaq -0x70(%rbp), %rsi
movq %r14, %rdi
callq 0x3a7fc
leaq -0x70(%rbp), %rdi
callq 0x35180
leaq -0x30(%rbp), %rdi
callq 0x35180
movsbl 0xf8(%rbx), %esi
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x3aa94
leaq 0x19c69(%rip), %rsi     # 0x5788f
leaq -0x50(%rbp), %rdi
movq %rbx, %rdx
callq 0x3e4a8
leaq -0x50(%rbp), %rsi
movq %r14, %rdi
callq 0x3a7fc
leaq -0x50(%rbp), %rdi
callq 0x35180
leaq -0x30(%rbp), %rdi
callq 0x35180
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
jmp 0x3dc6b
jmp 0x3dc72
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x35180
jmp 0x3dc75
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x35180
movq %rbx, %rdi
callq 0x355f0
// File: /workspace/github_cpp_makefile_star2_O2/CoinXu[P]reviser-compiler/src/compiler/code_generator.cpp
// Function: reviser::compiler::CodeGenerator::Generate[abi:cxx11]()
string CodeGenerator::Generate() {
    string code;
    for (StmtSeqItem it: seq) {
      switch(it.type) {
        case STMT_TYPE_STRUCT:
          code += StmtStruct(structures.at(it.index));
          break;

        case STMT_TYPE_ENUM:
          code += StmtEnum(enums.at(it.index));
          break;

        default:
          break;
      }
    }

    return code;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r15
movq 0x10(%rsi), %r12
leaq 0x38(%rsi), %rax
movq %rax, -0x38(%rbp)
leaq 0x20(%rsi), %rax
movq %rax, -0x30(%rbp)
leaq -0x58(%rbp), %r13
cmpq %r12, %r15
je 0x3ff97
movl (%r15), %eax
movq 0x8(%r15), %rsi
testl %eax, %eax
je 0x3ff66
cmpl $0x1, %eax
jne 0x3ff91
movq -0x30(%rbp), %rdi
callq 0x400ba
movq (%rax), %rdx
movq (%r14), %rax
movq %r13, %rdi
movq %r14, %rsi
callq *(%rax)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x35670
jmp 0x3ff89
movq -0x38(%rbp), %rdi
callq 0x400dc
movq (%rax), %rdx
movq (%r14), %rax
movq %r13, %rdi
movq %r14, %rsi
callq *0x8(%rax)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x35670
movq %r13, %rdi
callq 0x35180
addq $0x10, %r15
jmp 0x3ff2d
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3ffab
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x35180
jmp 0x3ffbe
jmp 0x3ffbb
movq %rax, %r14
movq %rbx, %rdi
callq 0x35180
movq %r14, %rdi
callq 0x355f0
// File: /workspace/github_cpp_makefile_star2_O2/CoinXu[P]reviser-compiler/src/compiler/code_generator.cpp
// Function: reviser::compiler::CodeGenerator::IncludeArrayType()
bool CodeGenerator::IncludeArrayType() {
    vector<Struct*> structs(structures.begin(), structures.end());

    for (Struct* s: structs) {
      for (StructProperty* p: s->properties) {
        if (p->declare->array_type) {
          return true;
        }
      }

      if (s->structs.size() > 0) {
        structs.insert(structs.end(), s->structs.begin(), s->structs.end());
      }
    }

    return false;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x20(%rdi), %rsi
movq 0x28(%rdi), %rdx
leaq -0x38(%rbp), %rbx
leaq -0x19(%rbp), %rcx
movq %rbx, %rdi
callq 0x400fe
movq (%rbx), %r14
movq 0x8(%rbx), %r15
cmpq %r15, %r14
je 0x40089
movq (%r14), %rax
movq 0x38(%rax), %rcx
movq 0x40(%rax), %rdx
cmpq %rdx, %rcx
je 0x4006a
movq (%rcx), %rsi
movq 0x48(%rsi), %rsi
addq $0x8, %rcx
cmpb $0x0, 0x4(%rsi)
je 0x40052
jmp 0x40089
movq 0x50(%rax), %rdx
movq 0x58(%rax), %rcx
cmpq %rdx, %rcx
je 0x40083
movq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x40130
addq $0x8, %r14
jmp 0x40042
cmpq %r15, %r14
setne %bl
leaq -0x38(%rbp), %rdi
callq 0x3f7da
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x3f7da
movq %rbx, %rdi
callq 0x355f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/CoinXu[P]reviser-compiler/src/compiler/descriptor.cpp
// Function: reviser::compiler::Descriptor::FindContextVariableById(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Descriptor::ContextVariable* Descriptor::FindContextVariableById(string id) {
    if (context.size() < 1) {
      return nullptr;
    }

    for (int i = context.size() - 1; i >= 0; i--) {
      vector<ContextVariable> v = context.at(i);
      if (v.size() < 1) {
        continue;
      }

      for (int j = v.size() - 1; j >= 0; j--) {
        if (v.at(j).id == id) {
          return &v.at(j);
        }
      }
    }
    return nullptr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x50(%rdi), %rax
subq 0x48(%rdi), %rax
je 0x411eb
movq %rsi, %r14
addq $0x48, %rdi
pushq $0x18
popq %rcx
cqto
idivq %rcx
movl %eax, %ebx
leaq -0x48(%rbp), %r12
movq %rdi, -0x30(%rbp)
decq %rbx
testl %ebx, %ebx
js 0x411eb
movl %ebx, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
callq 0x416c2
movq %r12, %rdi
movq %rax, %rsi
callq 0x416e0
movq -0x40(%rbp), %rax
subq -0x48(%rbp), %rax
je 0x411c3
cqto
pushq $0x30
popq %rcx
idivq %rcx
movl %eax, %r15d
decq %r15
testl %r15d, %r15d
js 0x411c3
movl %r15d, %r13d
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
movq %r12, %rdi
movq %r13, %rsi
callq 0x4173a
movq %rax, %rdi
movq %r14, %rsi
callq 0x39c78
decq %r15
testb %al, %al
je 0x41195
jmp 0x411d1
movq %r12, %rdi
callq 0x4167c
movq -0x30(%rbp), %rdi
jmp 0x4115a
leaq -0x48(%rbp), %rdi
movq %r13, %rsi
callq 0x4173a
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x4167c
jmp 0x411ed
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x41201
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x4167c
movq %rbx, %rdi
callq 0x355f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/CoinXu[P]reviser-compiler/src/compiler/descriptor.cpp
// Function: reviser::compiler::Descriptor::FindCurrentContextVariableById(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Descriptor::ContextVariable* Descriptor::FindCurrentContextVariableById(string id) {
    if (context.size() < 1) {
      return nullptr;
    }

    vector<ContextVariable> v = context.back();
    for (int i = v.size() - 1; i >= 0; i--) {
      if (v.at(i).id == id) {
        return &v.at(i);
      }
    }

    return nullptr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq 0x50(%rdi), %rsi
cmpq 0x48(%rdi), %rsi
je 0x412a7
addq $-0x18, %rsi
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x416e0
movq 0x8(%r14), %rax
subq (%r14), %rax
pushq $0x30
popq %rcx
cqto
idivq %rcx
movl %eax, %ecx
decq %rcx
movq %rcx, %r12
testl %r12d, %r12d
js 0x41293
movl %r12d, %r15d
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
movq %r14, %rdi
movq %r15, %rsi
callq 0x4173a
movq %rax, %rdi
movq %rbx, %rsi
callq 0x39c78
leaq -0x1(%r12), %rcx
testb %al, %al
je 0x41256
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x4173a
xorl %ebx, %ebx
testl %r12d, %r12d
cmovnsq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x4167c
jmp 0x412a9
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x412bb
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x4167c
movq %rbx, %rdi
callq 0x355f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/CoinXu[P]reviser-compiler/src/compiler/descriptor.cpp
// Function: reviser::compiler::Descriptor::FindContextVariableTypeById(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
DeclareType Descriptor::FindContextVariableTypeById(string id) {
    ContextVariable* variable = FindContextVariableById(id);
    if (!variable) {
      return DECLARE_UNDEFINED;
    }

    return variable->type;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x35470
movq %rbx, %rdi
movq %r14, %rsi
callq 0x41122
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x35180
testq %rbx, %rbx
je 0x4130b
movl 0x20(%rbx), %eax
jmp 0x4130e
pushq $0x2
popq %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x35180
movq %rbx, %rdi
callq 0x355f0
nop