LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: alfanick[P]rest-cpp/src/rest/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>::dump(int) const
string_t dump(const int indent = -1) const
    {
        std::stringstream ss;

        if (indent >= 0)
        {
            dump(ss, true, static_cast<unsigned int>(indent));
        }
        else
        {
            dump(ss, false, 0);
        }

        return ss.str();
    }

// Assembly:
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x1c0(%rsp)
movq %rsi, 0x1b8(%rsp)
movl %edx, 0x1b4(%rsp)
movq 0x1b8(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x91140
cmpl $0x0, 0x1b4(%rsp)
jl 0xdeaf7
movq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
movl 0x1b4(%rsp), %ecx
movl $0x1, %edx
xorl %r8d, %r8d
callq 0x8d410
jmp 0xdeadb
jmp 0xdeb13
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x91450
jmp 0xdeb3a
movq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
xorl %r8d, %r8d
movl %r8d, %edx
movl %r8d, %ecx
callq 0x8d410
jmp 0xdeb11
jmp 0xdeb13
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x92fd0
jmp 0xdeb23
leaq 0x28(%rsp), %rdi
callq 0x91450
movq 0x8(%rsp), %rax
addq $0x1c8, %rsp            # imm = 0x1C8
retq
movq 0x20(%rsp), %rdi
callq 0x981c0
nopw %cs:(%rax,%rax)
nop
// File: alfanick[P]rest-cpp/src/rest/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>::extra_space(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::size_t extra_space(const string_t& s) noexcept
    {
        std::size_t result = 0;

        for (const auto& c : s)
        {
            switch (c)
            {
                case '"':
                case '\\':
                case '\b':
                case '\f':
                case '\n':
                case '\r':
                case '\t':
                {
                    // from c (1 byte) to \x (2 bytes)
                    result += 1;
                    break;
                }

                default:
                {
                    if (c >= 0x00 and c <= 0x1f)
                    {
                        // from c (1 byte) to \uxxxx (6 bytes)
                        result += 5;
                    }
                    break;
                }
            }
        }

        return result;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x92d40
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x98cc0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x8e2a0
testb $0x1, %al
jne 0xe0302
jmp 0xe0396
leaq 0x18(%rsp), %rdi
callq 0x97ef0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
movl %eax, 0x4(%rsp)
addl $-0x8, %eax
subl $0x3, %eax
jb 0xe034b
jmp 0xe0327
movl 0x4(%rsp), %eax
addl $-0xc, %eax
subl $0x2, %eax
jb 0xe034b
jmp 0xe0335
movl 0x4(%rsp), %eax
subl $0x22, %eax
je 0xe034b
jmp 0xe0340
movl 0x4(%rsp), %eax
subl $0x5c, %eax
jne 0xe035b
jmp 0xe034b
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0xe0385
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jl 0xe0383
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x1f, %eax
jg 0xe0383
movq 0x28(%rsp), %rax
addq $0x5, %rax
movq %rax, 0x28(%rsp)
jmp 0xe0385
jmp 0xe0387
leaq 0x18(%rsp), %rdi
callq 0x90c30
jmp 0xe02ea
movq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
// File: alfanick[P]rest-cpp/src/rest/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>::size() const
size_type size() const noexcept
    {
        switch (m_type)
        {
            case value_t::null:
            {
                // null values are empty
                return 0;
            }

            case value_t::array:
            {
                assert(m_value.array != nullptr);
                return m_value.array->size();
            }

            case value_t::object:
            {
                assert(m_value.object != nullptr);
                return m_value.object->size();
            }

            default:
            {
                // all other types have size 1
                return 1;
            }
        }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movb (%rax), %al
movb %al, 0x17(%rsp)
testb %al, %al
je 0xe0506
jmp 0xe04ef
movb 0x17(%rsp), %al
subb $0x1, %al
je 0xe0556
jmp 0xe04f9
movb 0x17(%rsp), %al
subb $0x2, %al
je 0xe0514
jmp 0xe0598
movq $0x0, 0x20(%rsp)
jmp 0xe05a1
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe0522
jmp 0xe0541
leaq 0x4909(%rip), %rdi      # 0xe4e32
leaq 0x3e57(%rip), %rsi      # 0xe4387
movl $0x1017, %edx           # imm = 0x1017
leaq 0x6af5(%rip), %rcx      # 0xe7031
callq 0x90c40
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x93c30
movq %rax, 0x20(%rsp)
jmp 0xe05a1
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe0564
jmp 0xe0583
leaq 0x474e(%rip), %rdi      # 0xe4cb9
leaq 0x3e15(%rip), %rsi      # 0xe4387
movl $0x101d, %edx           # imm = 0x101D
leaq 0x6ab3(%rip), %rcx      # 0xe7031
callq 0x90c40
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x8f9e0
movq %rax, 0x20(%rsp)
jmp 0xe05a1
movq $0x1, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: alfanick[P]rest-cpp/src/rest/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>::operator[](unsigned long) const
const_reference operator[](size_type idx) const
    {
        // at only works for arrays
        if (is_array())
        {
            assert(m_value.array != nullptr);
            return m_value.array->operator[](idx);
        }
        else
        {
            throw std::domain_error("cannot use operator[] with " + type_name());
        }
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x960f0
testb $0x1, %al
jne 0xe05d3
jmp 0xe0618
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe05e1
jmp 0xe0600
leaq 0x484a(%rip), %rdi      # 0xe4e32
leaq 0x3d98(%rip), %rsi      # 0xe4387
movl $0xb96, %edx            # imm = 0xB96
leaq 0x6b24(%rip), %rcx      # 0xe711f
callq 0x90c40
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x68(%rsp), %rsi
callq 0x93de0
addq $0x78, %rsp
retq
movb $0x1, 0x1b(%rsp)
movl $0x10, %edi
callq 0x8f970
movq 0x10(%rsp), %rsi
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x95540
jmp 0xe063d
leaq 0x4294(%rip), %rsi      # 0xe48d8
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x97a00
jmp 0xe0655
movq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x94700
jmp 0xe0666
movq 0x8(%rsp), %rdi
movb $0x0, 0x1b(%rsp)
movq 0x255b1(%rip), %rsi     # 0x105c28
movq 0x256c2(%rip), %rdx     # 0x105d40
callq 0x97c60
jmp 0xe06e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0xe06c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0xe06bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x99830
leaq 0x28(%rsp), %rdi
callq 0x99830
testb $0x1, 0x1b(%rsp)
jne 0xe06d0
jmp 0xe06da
movq 0x8(%rsp), %rdi
callq 0x911a0
jmp 0xe06dc
movq 0x20(%rsp), %rdi
callq 0x981c0
nopw %cs:(%rax,%rax)
// File: alfanick[P]rest-cpp/src/rest/server.cpp
// Function: REST::Server::Server(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, REST::Dispatcher*)
Server::Server(std::string path, Dispatcher* d) : dispatcher(d) {
  srand(time(0));
  signal(SIGPIPE, SIG_IGN);
  Router::instance();

  unlink(path.c_str());
  struct sockaddr_un local;
  handle = socket(AF_UNIX, SOCK_STREAM, 0);
  local.sun_family = AF_UNIX;
  strcpy(local.sun_path, path.c_str());

  if (bind(handle, (struct sockaddr *)&local, strlen(local.sun_path) + sizeof(local.sun_family) + 1) == -1)
    throw PortInUseError();

}

// Assembly:
subq $0xb8, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0xa0(%rsp), %rcx
movq %rcx, (%rax)
movb $0x1, 0x8(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x92a80
movl %eax, %edi
callq 0x92d90
movl $0xd, %edi
movl $0x1, %esi
callq 0x94520
callq 0x8ee40
movq 0x10(%rsp), %rdi
callq 0x8f110
movq %rax, %rdi
callq 0x8f760
movl $0x1, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x8e250
movq 0x10(%rsp), %rdi
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x48(%rax)
movw $0x1, 0x32(%rsp)
leaq 0x32(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x18(%rsp)
callq 0x8f110
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x92b40
movq 0x20(%rsp), %rax
movl 0x48(%rax), %eax
movl %eax, 0x2c(%rsp)
leaq 0x32(%rsp), %rdi
addq $0x2, %rdi
callq 0x8f450
movl 0x2c(%rsp), %edi
addq $0x2, %rax
addq $0x1, %rax
movl %eax, %edx
leaq 0x32(%rsp), %rsi
callq 0x8d9a0
cmpl $-0x1, %eax
jne 0xe1eb1
movl $0x8, %edi
callq 0x8f970
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x8ffc0
movq 0x8(%rsp), %rdi
callq 0x90800
movq 0x8(%rsp), %rdi
movq 0x23d8b(%rip), %rsi     # 0x105c30
movq 0x23ef4(%rip), %rdx     # 0x105da0
callq 0x97c60
addq $0xb8, %rsp
retq
nopl (%rax)
// File: alfanick[P]rest-cpp/src/rest/server.cpp
// Function: REST::Server::~Server()
Server::~Server() {
  is_running = false;

  delete dispatcher;

  freeaddrinfo(host_info_list);
  close(handle);

#ifdef SERVER_PATH
  unlink(STR(SERVER_PATH));
#endif
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movb $0x0, 0x8(%rax)
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xe217f
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq (%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x94f00
movq (%rsp), %rax
movl 0x48(%rax), %edi
callq 0x99370
jmp 0xe219a
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0x9b760
nopw (%rax,%rax)
// File: alfanick[P]rest-cpp/src/rest/server.cpp
// Function: REST::Server::run()
void Server::run() {
  int status;

  router()->print();

  status = listen(handle, SOMAXCONN);
  if (status == -1)
    throw ServerError();

  while (is_running) {
    Request::client client;
    socklen_t addr_size = sizeof(client.address);
    client.handle = accept(handle, (struct sockaddr *)&(client.address), &addr_size);

    try {
      if (client.handle == -1)
        throw ServerError();

      dispatcher->next(client);
    } catch (Exception &e) {
      if (is_running)
        std::cerr << "!!! " << e.what() << std::endl;
      close(client.handle);
    }
  }
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq 0xe0(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x8f1d0
movq %rax, %rdi
callq 0x91760
movq 0x28(%rsp), %rax
movl 0x48(%rax), %edi
movl $0x1000, %esi           # imm = 0x1000
callq 0x93f50
movl %eax, 0xdc(%rsp)
cmpl $-0x1, 0xdc(%rsp)
jne 0xe223c
movl $0x8, %edi
callq 0x8f970
movq %rax, %rdi
movq %rdi, 0x20(%rsp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x8ffc0
movq 0x20(%rsp), %rdi
callq 0x8d3c0
movq 0x20(%rsp), %rdi
movq 0x23978(%rip), %rsi     # 0x105ba8
movq 0x23cd9(%rip), %rdx     # 0x105f10
callq 0x97c60
jmp 0xe223e
movq 0x28(%rsp), %rax
testb $0x1, 0x8(%rax)
je 0xe238e
movq 0x28(%rsp), %rax
movl $0x80, 0x4c(%rsp)
movl 0x48(%rax), %edi
leaq 0x50(%rsp), %rsi
leaq 0x4c(%rsp), %rdx
callq 0x8e9e0
movl %eax, 0xd0(%rsp)
cmpl $-0x1, 0xd0(%rsp)
jne 0xe2349
movl $0x8, %edi
callq 0x8f970
movq %rax, %rdi
movq %rdi, 0x18(%rsp)
movq $0x0, (%rdi)
callq 0x8d3c0
movq 0x18(%rsp), %rdi
movq 0x238fd(%rip), %rsi     # 0x105ba8
movq 0x23c5e(%rip), %rdx     # 0x105f10
callq 0x97c60
jmp 0xe23a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xe2396
movq 0x40(%rsp), %rdi
callq 0x8f0f0
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x30(%rsp)
testb $0x1, 0x8(%rax)
je 0xe2374
movq 0x23cd1(%rip), %rdi     # 0x105fd0
leaq 0x50d5(%rip), %rsi      # 0xe73db
callq 0x930c0
movq %rax, 0x10(%rsp)
jmp 0xe2312
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x930c0
movq %rax, 0x8(%rsp)
jmp 0xe2334
movq 0x8(%rsp), %rdi
movq 0x238b8(%rip), %rsi     # 0x105bf8
callq 0x935c0
jmp 0xe2347
jmp 0xe2374
movq 0x28(%rsp), %rax
movq (%rax), %rdi
leaq 0x50(%rsp), %rsi
callq 0x987b0
jmp 0xe235d
jmp 0xe2387
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x97420
jmp 0xe238c
movl 0xd0(%rsp), %edi
callq 0x99370
jmp 0xe2382
callq 0x97420
jmp 0xe223e
jmp 0xe2396
addq $0xe8, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x981c0
movq %rax, %rdi
callq 0x9b760
nopl (%rax,%rax)
// File: ryuichiueda[P]GlueLang/src/ArgExtCom.cc
// Function: ArgExtCom::parsePrefixedCom()
bool ArgExtCom::parsePrefixedCom(void)
{
	struct stat buf;
	auto paths = m_env->getImportPaths(&m_prefix);
	if(paths == NULL)
		return false;

	for(auto path : *paths){
		m_evaled_text = path + m_text;
		if(stat(m_evaled_text.c_str(), &buf) != 0)
			continue;

		m_feeder->getPos(&m_end_line, &m_end_char);
		return true;
	}
	m_error_msg = "Command " + m_text  + " not exist";
	m_exit_status = 2;
	m_feeder->getPos(&m_end_line, &m_end_char);
	throw this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x158(%rbp)
movq 0x10(%rsi), %rdi
addq $0xc8, %rsi
callq 0xe6c0
movq %rax, -0xa8(%rbp)
cmpq $0x0, -0xa8(%rbp)
jne 0x76d4
movb $0x0, -0x1(%rbp)
jmp 0x791d
movq -0xa8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rdi
callq 0x7af0
movq %rax, -0xb8(%rbp)
movq -0xb0(%rbp), %rdi
callq 0x7b20
movq %rax, -0xc0(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x7b50
testb $0x1, %al
jne 0x7724
jmp 0x783e
leaq -0xb8(%rbp), %rdi
callq 0x7b90
movq %rax, %rsi
leaq -0xe0(%rbp), %rdi
movq %rdi, -0x160(%rbp)
callq 0x61a0
movq -0x158(%rbp), %rdx
movq -0x160(%rbp), %rsi
addq $0x88, %rdx
leaq -0x100(%rbp), %rdi
callq 0x7a70
jmp 0x7769
movq -0x158(%rbp), %rdi
addq $0xa8, %rdi
leaq -0x100(%rbp), %rsi
callq 0x6520
leaq -0x100(%rbp), %rdi
callq 0x6280
movq -0x158(%rbp), %rdi
addq $0xa8, %rdi
callq 0x6190
movq %rax, %rdi
leaq -0xa0(%rbp), %rsi
callq 0x63b0
cmpl $0x0, %eax
je 0x77e5
movl $0x3, -0x110(%rbp)
jmp 0x7810
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x6280
jmp 0x792b
movq -0x158(%rbp), %rdx
movq 0x8(%rdx), %rdi
movq %rdx, %rsi
addq $0x38, %rsi
addq $0x3c, %rdx
callq 0x17610
jmp 0x7802
movb $0x1, -0x1(%rbp)
movl $0x1, -0x110(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x6280
movl -0x110(%rbp), %eax
subl $0x1, %eax
je 0x791d
jmp 0x782d
leaq -0xb8(%rbp), %rdi
callq 0x7bb0
jmp 0x7708
movq -0x158(%rbp), %rdx
addq $0x88, %rdx
leaq 0x157cb(%rip), %rsi     # 0x1d01e
leaq -0x150(%rbp), %rdi
movq %rdi, -0x168(%rbp)
callq 0x7c20
movq -0x168(%rbp), %rsi
leaq 0x157b3(%rip), %rdx     # 0x1d027
leaq -0x130(%rbp), %rdi
callq 0x7bd0
jmp 0x7882
movq -0x158(%rbp), %rdi
addq $0x60, %rdi
leaq -0x130(%rbp), %rsi
callq 0x6520
leaq -0x130(%rbp), %rdi
callq 0x6280
leaq -0x150(%rbp), %rdi
callq 0x6280
movq -0x158(%rbp), %rdx
movl $0x2, 0x80(%rdx)
movq 0x8(%rdx), %rdi
movq %rdx, %rsi
addq $0x38, %rsi
addq $0x3c, %rdx
callq 0x17610
movl $0x8, %edi
callq 0x6200
movq %rax, %rdi
movq -0x158(%rbp), %rax
movq %rax, (%rdi)
leaq 0x2071c(%rip), %rsi     # 0x28010
xorl %eax, %eax
movl %eax, %edx
callq 0x66d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
leaq -0x150(%rbp), %rdi
callq 0x6280
jmp 0x792b
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
movq -0x108(%rbp), %rdi
callq 0x6700
nopw (%rax,%rax)
// File: ryuichiueda[P]GlueLang/src/ArgIntCom.cc
// Function: ArgIntCom::parse()
bool ArgIntCom::parse(void)
{
	m_feeder->getPos(&m_start_line, &m_start_char);

	m_feeder->str("in.");

	string tmp;
	if(!m_feeder->variable(&m_evaled_text)){
		m_feeder->setPos(m_start_line, m_start_char);
		return false;
	}

	m_text = "in." + m_evaled_text;

	if(m_evaled_text != "wait" && !InternalCommands::exist(&m_evaled_text)){
		m_feeder->setPos(m_start_line, m_start_char);
		return false;
	}


	m_feeder->getPos(&m_end_line, &m_end_char);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movq %rdx, -0xa8(%rbp)
movq 0x8(%rdx), %rdi
movq %rdx, %rsi
addq $0x30, %rsi
addq $0x34, %rdx
callq 0x17610
movq -0xa8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xa0(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x6710
movq -0x98(%rbp), %rdx
leaq 0x14f15(%rip), %rsi     # 0x1d073
leaq -0x30(%rbp), %rdi
callq 0x7940
jmp 0x8169
movq -0xa0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x17750
jmp 0x817b
leaq -0x30(%rbp), %rdi
callq 0x6280
leaq -0x31(%rbp), %rdi
callq 0x6480
leaq -0x68(%rbp), %rdi
callq 0x65a0
movq -0xa8(%rbp), %rsi
movq 0x8(%rsi), %rdi
addq $0xa8, %rsi
callq 0x16a90
movb %al, -0xa9(%rbp)
jmp 0x81b5
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0x8234
jmp 0x81c1
movq -0xa8(%rbp), %rax
movq 0x8(%rax), %rdi
movl 0x30(%rax), %esi
movl 0x34(%rax), %edx
callq 0x16c90
jmp 0x81d9
movb $0x0, -0x1(%rbp)
movl $0x1, -0x6c(%rbp)
jmp 0x8326
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x820c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6280
leaq -0x31(%rbp), %rdi
callq 0x6480
jmp 0x833d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x6280
jmp 0x833d
movq -0xa8(%rbp), %rdx
addq $0xa8, %rdx
leaq 0x14e2a(%rip), %rsi     # 0x1d073
leaq -0x90(%rbp), %rdi
callq 0x7c20
jmp 0x8257
movq -0xa8(%rbp), %rdi
addq $0x88, %rdi
leaq -0x90(%rbp), %rsi
movq %rsi, -0xb8(%rbp)
callq 0x6520
movq -0xb8(%rbp), %rdi
callq 0x6280
movq -0xa8(%rbp), %rdi
addq $0xa8, %rdi
leaq 0x1526b(%rip), %rsi     # 0x1d504
callq 0x8350
movb %al, -0xaa(%rbp)
jmp 0x82a6
movb -0xaa(%rbp), %al
testb $0x1, %al
jne 0x82b2
jmp 0x82fe
movq -0xa8(%rbp), %rdi
addq $0xa8, %rdi
callq 0x18970
movb %al, -0xb9(%rbp)
jmp 0x82cd
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0x82fe
jmp 0x82d9
movq -0xa8(%rbp), %rax
movq 0x8(%rax), %rdi
movl 0x30(%rax), %esi
movl 0x34(%rax), %edx
callq 0x16c90
jmp 0x82f1
movb $0x0, -0x1(%rbp)
movl $0x1, -0x6c(%rbp)
jmp 0x8326
movq -0xa8(%rbp), %rdx
movq 0x8(%rdx), %rdi
movq %rdx, %rsi
addq $0x38, %rsi
addq $0x3c, %rdx
callq 0x17610
jmp 0x831b
movb $0x1, -0x1(%rbp)
movl $0x1, -0x6c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x6280
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x6700
nopw %cs:(%rax,%rax)
// File: ryuichiueda[P]GlueLang/src/ArgVariable.cc
// Function: ArgVariable::parse()
bool ArgVariable::parse(void)
{
	m_feeder->getPos(&m_start_line, &m_start_char);

	if(m_feeder->str("local.")){
		m_is_local = true;
	}else if(m_feeder->str("this.")){
		m_is_proc = true;
	}

	if(!m_feeder->variable(&m_text))
		return false;

	if(m_is_local)
		m_text = "local." + m_text;
//	else if(m_is_proc)
//	m_text = "this." + m_text;

	m_feeder->getPos(&m_end_line, &m_end_char);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movq %rdx, -0xa8(%rbp)
movq 0x8(%rdx), %rdi
movq %rdx, %rsi
addq $0x30, %rsi
addq $0x34, %rdx
callq 0x17610
movq -0xa8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xa0(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x6710
movq -0x98(%rbp), %rdx
leaq 0x14813(%rip), %rsi     # 0x1d091
leaq -0x30(%rbp), %rdi
callq 0x7940
jmp 0x8889
movq -0xa0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x17750
movb %al, -0xa9(%rbp)
jmp 0x88a1
leaq -0x30(%rbp), %rdi
callq 0x6280
leaq -0x31(%rbp), %rdi
callq 0x6480
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0x88bf
jmp 0x8903
movq -0xa8(%rbp), %rax
movb $0x1, 0xc8(%rax)
jmp 0x89b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x88f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6280
leaq -0x31(%rbp), %rdi
callq 0x6480
jmp 0x8a5c
movq -0xa8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xc0(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x6710
movq -0xb8(%rbp), %rdx
leaq 0x1474f(%rip), %rsi     # 0x1d082
leaq -0x68(%rbp), %rdi
callq 0x7940
jmp 0x893e
movq -0xc0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x17750
movb %al, -0xc1(%rbp)
jmp 0x8956
leaq -0x68(%rbp), %rdi
callq 0x6280
leaq -0x69(%rbp), %rdi
callq 0x6480
movb -0xc1(%rbp), %al
testb $0x1, %al
jne 0x8974
jmp 0x89b5
movq -0xa8(%rbp), %rax
movb $0x1, 0xc9(%rax)
jmp 0x89b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x89a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x6280
leaq -0x69(%rbp), %rdi
callq 0x6480
jmp 0x8a5c
jmp 0x89b7
movq -0xa8(%rbp), %rsi
movq 0x8(%rsi), %rdi
addq $0x88, %rsi
callq 0x16a90
testb $0x1, %al
jne 0x89d8
movb $0x0, -0x1(%rbp)
jmp 0x8a4e
movq -0xa8(%rbp), %rax
testb $0x1, 0xc8(%rax)
je 0x8a2f
movq -0xa8(%rbp), %rdx
addq $0x88, %rdx
leaq -0x90(%rbp), %rdi
leaq 0x1468d(%rip), %rsi     # 0x1d091
callq 0x7c20
movq -0xa8(%rbp), %rdi
addq $0x88, %rdi
leaq -0x90(%rbp), %rsi
callq 0x6520
leaq -0x90(%rbp), %rdi
callq 0x6280
movq -0xa8(%rbp), %rdx
movq 0x8(%rdx), %rdi
movq %rdx, %rsi
addq $0x38, %rsi
addq $0x3c, %rdx
callq 0x17610
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x6700
nopw %cs:(%rax,%rax)
// File: ryuichiueda[P]GlueLang/src/ArgVariable.cc
// Function: ArgVariable::eval()
bool ArgVariable::eval(void)
{
	try{
		Data *p;
		//if(m_is_local){
		//	p = m_env->m_local_env[m_job_id]->getData(&m_text);
		//}else{
			p = m_env->getData(&m_scopes,&m_text);
		//}
		m_evaled_text = p->m_value;
	}catch(...){
		m_error_msg = m_env->m_error_msg;
		m_exit_status = 3;
		throw this;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdx
movq %rdx, -0x30(%rbp)
movq 0x10(%rdx), %rdi
movq %rdx, %rsi
addq $0x48, %rsi
addq $0x88, %rdx
callq 0xec10
movq %rax, -0x28(%rbp)
jmp 0x8aa1
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
addq $0xa8, %rdi
callq 0x6070
jmp 0x8ac3
jmp 0x8b3d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6180
movq -0x30(%rbp), %rdi
movq 0x10(%rdi), %rsi
addq $0xa0, %rsi
addq $0x60, %rdi
callq 0x6070
jmp 0x8af4
movq -0x30(%rbp), %rax
movl $0x3, 0x80(%rax)
movl $0x8, %edi
callq 0x6200
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq %rax, (%rdi)
leaq 0x1f663(%rip), %rsi     # 0x28180
xorl %eax, %eax
movl %eax, %edx
callq 0x66d0
jmp 0x8b58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x6690
jmp 0x8b3b
jmp 0x8b47
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x6700
movq %rax, %rdi
callq 0x7f90
nopl (%rax,%rax)
// File: ryuichiueda[P]GlueLang/src/ArrayVariable.cc
// Function: ArrayVariable::parse()
bool ArrayVariable::parse(void)
{
	m_feeder->getPos(&m_start_line, &m_start_char);

	try{
		if(!m_feeder->arrayElem(&m_text,&m_array_pos))
			return false;

	}catch(Feeder *e){
		m_feeder->getPos(&m_end_line, &m_end_char);
		m_error_msg = e->m_error_msg;
		m_exit_status = 3;
		throw this;
	}

	m_feeder->getPos(&m_end_line, &m_end_char);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movq %rdx, -0x38(%rbp)
movq 0x8(%rdx), %rdi
movq %rdx, %rsi
addq $0x30, %rsi
addq $0x34, %rdx
callq 0x17610
movq -0x38(%rbp), %rdx
movq 0x8(%rdx), %rdi
movq %rdx, %rsi
addq $0x88, %rsi
addq $0xc8, %rdx
callq 0x168e0
movb %al, -0x29(%rbp)
jmp 0x8c4b
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x8cef
jmp 0x8c58
movb $0x0, -0x1(%rbp)
jmp 0x8d20
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x8d2b
movq -0x18(%rbp), %rdi
callq 0x6180
movq -0x38(%rbp), %rdx
movq %rax, -0x28(%rbp)
movq 0x8(%rdx), %rdi
movq %rdx, %rsi
addq $0x38, %rsi
addq $0x3c, %rdx
callq 0x17610
jmp 0x8ca4
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x28, %rsi
addq $0x60, %rdi
callq 0x6070
jmp 0x8cbb
movq -0x38(%rbp), %rax
movl $0x3, 0x80(%rax)
movl $0x8, %edi
callq 0x6200
movq %rax, %rdi
movq -0x38(%rbp), %rax
movq %rax, (%rdi)
leaq 0x1f55c(%rip), %rsi     # 0x28240
xorl %eax, %eax
movl %eax, %edx
callq 0x66d0
jmp 0x8d34
jmp 0x8d04
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x6690
jmp 0x8d2b
movq -0x38(%rbp), %rdx
movq 0x8(%rdx), %rdi
movq %rdx, %rsi
addq $0x38, %rsi
addq $0x3c, %rdx
callq 0x17610
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x6700
nopw %cs:(%rax,%rax)
// File: ryuichiueda[P]GlueLang/src/ArrayVariable.cc
// Function: ArrayVariable::eval()
bool ArrayVariable::eval(void)
{
	if(m_text != "argv"){
		// treat as a literal until array can be declared in scripts.
		m_evaled_text = m_text + "[" + to_string(m_array_pos) + "]";
		return true;
	}

	try{
		m_evaled_text = *m_env->getArg(m_array_pos);
	}catch(Environment *e){
		m_error_msg = e->m_error_msg;
		m_exit_status = 3;
		throw this;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
addq $0x88, %rdi
leaq 0x1437f(%rip), %rsi     # 0x1d0e7
callq 0x8350
testb $0x1, %al
jne 0x8d76
jmp 0x8e80
movq -0xb0(%rbp), %rsi
addq $0x88, %rsi
leaq 0x14849(%rip), %rdx     # 0x1d5d4
leaq -0x70(%rbp), %rdi
callq 0x79f0
movq -0xb0(%rbp), %rax
movq 0xc8(%rax), %rsi
leaq -0x90(%rbp), %rdi
callq 0x9060
jmp 0x8db0
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x8f90
jmp 0x8dc6
leaq 0x14b55(%rip), %rdx     # 0x1d922
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x7bd0
jmp 0x8ddc
movq -0xb0(%rbp), %rdi
addq $0xa8, %rdi
leaq -0x30(%rbp), %rsi
callq 0x6520
leaq -0x30(%rbp), %rdi
callq 0x6280
leaq -0x50(%rbp), %rdi
callq 0x6280
leaq -0x90(%rbp), %rdi
callq 0x6280
leaq -0x70(%rbp), %rdi
callq 0x6280
movb $0x1, -0x1(%rbp)
jmp 0x8f70
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x8e72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x8e66
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x6280
leaq -0x90(%rbp), %rdi
callq 0x6280
leaq -0x70(%rbp), %rdi
callq 0x6280
jmp 0x8f7e
movq -0xb0(%rbp), %rax
movq 0x10(%rax), %rdi
movq 0xc8(%rax), %rsi
callq 0xf110
movq %rax, -0xb8(%rbp)
jmp 0x8ea0
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdi
addq $0xa8, %rdi
callq 0x6070
jmp 0x8ebc
jmp 0x8f6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
movl -0x9c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x8f7e
movq -0x98(%rbp), %rdi
callq 0x6180
movq -0xb0(%rbp), %rdi
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rsi
addq $0xa0, %rsi
addq $0x60, %rdi
callq 0x6070
jmp 0x8f19
movq -0xb0(%rbp), %rax
movl $0x3, 0x80(%rax)
movl $0x8, %edi
callq 0x6200
movq %rax, %rdi
movq -0xb0(%rbp), %rax
movq %rax, (%rdi)
leaq 0x1f2f8(%rip), %rsi     # 0x28240
xorl %eax, %eax
movl %eax, %edx
callq 0x66d0
jmp 0x8f8a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
callq 0x6690
jmp 0x8f7e
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x6700
nopw (%rax,%rax)
// File: ryuichiueda[P]GlueLang/src/DataFile.cc
// Function: DataFile::openFile()
void DataFile::openFile(void)
{
	int mode = O_WRONLY | O_CREAT;
	if(m_append_mode)
		mode |= O_APPEND;

	int fd = open( m_value.c_str() , mode, 0600);
	if(fd < 3){
		m_error_msg = "file does not open.";
		throw this;
	}
	if(dup2(fd,1) < 0){
		m_error_msg = "file redirect error";
		throw this;
	}
	if( close(fd) < 0){
		m_error_msg = "file redirect error";
		throw this;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x41, -0xc(%rbp)
testb $0x1, 0x48(%rax)
je 0x952c
movl -0xc(%rbp), %eax
orl $0x400, %eax            # imm = 0x400
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x6190
movq %rax, %rdi
movl -0xc(%rbp), %esi
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x62f0
movl %eax, -0x10(%rbp)
cmpl $0x3, -0x10(%rbp)
jge 0x958c
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq 0x13c7c(%rip), %rsi     # 0x1d1df
callq 0x6580
movl $0x8, %edi
callq 0x6200
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq %rax, (%rdi)
leaq 0x1ed95(%rip), %rsi     # 0x28318
xorl %eax, %eax
movl %eax, %edx
callq 0x66d0
movl -0x10(%rbp), %edi
movl $0x1, %esi
callq 0x63d0
cmpl $0x0, %eax
jge 0x95d6
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq 0x13c46(%rip), %rsi     # 0x1d1f3
callq 0x6580
movl $0x8, %edi
callq 0x6200
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq %rax, (%rdi)
leaq 0x1ed4b(%rip), %rsi     # 0x28318
xorl %eax, %eax
movl %eax, %edx
callq 0x66d0
movl -0x10(%rbp), %edi
callq 0x6790
cmpl $0x0, %eax
jge 0x961b
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq 0x13c01(%rip), %rsi     # 0x1d1f3
callq 0x6580
movl $0x8, %edi
callq 0x6200
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq %rax, (%rdi)
leaq 0x1ed06(%rip), %rsi     # 0x28318
xorl %eax, %eax
movl %eax, %edx
callq 0x66d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ryuichiueda[P]GlueLang/src/DataStr.cc
// Function: DataStr::openFifo()
void DataStr::openFifo(void)
{
	int fd = open( m_filename.c_str() ,O_WRONLY ,0600);
	if(dup2(fd,1) < 0){
		m_error_msg = "str redirect error";
		throw this;
	}
	if( close(fd) < 0){
		m_error_msg = "str redirect error";
		throw this;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x48, %rdi
callq 0x6190
movq %rax, %rdi
movl $0x1, %esi
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x62f0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
movl $0x1, %esi
callq 0x63d0
cmpl $0x0, %eax
jge 0x99de
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq 0x13891(%rip), %rsi     # 0x1d246
callq 0x6580
movl $0x8, %edi
callq 0x6200
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq %rax, (%rdi)
leaq 0x1ea3b(%rip), %rsi     # 0x28410
xorl %eax, %eax
movl %eax, %edx
callq 0x66d0
movl -0xc(%rbp), %edi
callq 0x6790
cmpl $0x0, %eax
jge 0x9a23
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq 0x1384c(%rip), %rsi     # 0x1d246
callq 0x6580
movl $0x8, %edi
callq 0x6200
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq %rax, (%rdi)
leaq 0x1e9f6(%rip), %rsi     # 0x28410
xorl %eax, %eax
movl %eax, %edx
callq 0x66d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ryuichiueda[P]GlueLang/src/DataStr.cc
// Function: DataStr::readFifo()
void DataStr::readFifo(void)
{
	ifstream ifs(m_filename.c_str());
	string tmp;
	string value;
	if(m_is_set){
		value = "\n";
	}

	bool isfirst = true;
	while(ifs && getline(ifs, tmp)){
		if(isfirst){
			value += tmp;
			isfirst = false;
		}else
			value += "\n" + tmp;
	}

	m_is_set = true;
	m_value += value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x288(%rbp)
addq $0x48, %rdi
callq 0x6190
movq %rax, %rsi
leaq -0x210(%rbp), %rdi
movl $0x8, %edx
callq 0x6740
leaq -0x230(%rbp), %rdi
callq 0x65a0
leaq -0x250(%rbp), %rdi
callq 0x65a0
movq -0x288(%rbp), %rax
testb $0x1, 0x68(%rax)
je 0x9aba
leaq 0x13e4b(%rip), %rsi     # 0x1d8de
leaq -0x250(%rbp), %rdi
callq 0x6580
jmp 0x9aa1
jmp 0x9aba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x258(%rbp)
movl %eax, -0x25c(%rbp)
jmp 0x9c22
movb $0x1, -0x25d(%rbp)
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x6550
movb %al, -0x289(%rbp)
jmp 0x9ae1
movb -0x289(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x28a(%rbp)
jne 0x9af6
jmp 0x9b3e
leaq -0x210(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x60d0
movq %rax, -0x298(%rbp)
jmp 0x9b12
movq -0x298(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x6550
movb %al, -0x299(%rbp)
jmp 0x9b30
movb -0x299(%rbp), %al
movb %al, -0x28a(%rbp)
jmp 0x9b3e
movb -0x28a(%rbp), %al
testb $0x1, %al
jne 0x9b4d
jmp 0x9bd8
testb $0x1, -0x25d(%rbp)
je 0x9b74
leaq -0x250(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x6560
jmp 0x9b6b
movb $0x0, -0x25d(%rbp)
jmp 0x9bd3
leaq 0x13d63(%rip), %rsi     # 0x1d8de
leaq -0x280(%rbp), %rdi
leaq -0x230(%rbp), %rdx
callq 0x7c20
jmp 0x9b90
leaq -0x250(%rbp), %rdi
leaq -0x280(%rbp), %rsi
callq 0x6560
jmp 0x9ba5
leaq -0x280(%rbp), %rdi
callq 0x6280
jmp 0x9bd3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x258(%rbp)
movl %eax, -0x25c(%rbp)
leaq -0x280(%rbp), %rdi
callq 0x6280
jmp 0x9c22
jmp 0x9ac1
movq -0x288(%rbp), %rdi
movb $0x1, 0x68(%rdi)
addq $0x28, %rdi
leaq -0x250(%rbp), %rsi
callq 0x6560
jmp 0x9bf5
leaq -0x250(%rbp), %rdi
callq 0x6280
leaq -0x230(%rbp), %rdi
callq 0x6280
leaq -0x210(%rbp), %rdi
callq 0x6100
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
leaq -0x250(%rbp), %rdi
callq 0x6280
leaq -0x230(%rbp), %rdi
callq 0x6280
leaq -0x210(%rbp), %rdi
callq 0x6100
movq -0x258(%rbp), %rdi
callq 0x6700
nopw %cs:(%rax,%rax)
// File: ryuichiueda[P]GlueLang/src/DefFile.cc
// Function: DefFile::connect()
void DefFile::connect(void)
{
	try{
		m_data->openFile();
	}catch(DataFile *e){
		m_error_msg = e->m_error_msg;	
		m_exit_status = 1;
		throw this;
	}

	if(m_env->m_v_opt)
		cerr << "+ pid " << getpid() << " file "
		<< m_data->m_value << " created" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x88(%rax), %rdi
callq 0x9500
jmp 0xa362
jmp 0xa3f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xa476
movq -0x10(%rbp), %rdi
callq 0x6180
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
addq $0x60, %rdi
callq 0x6070
jmp 0xa3a7
movq -0x28(%rbp), %rax
movl $0x1, 0x80(%rax)
movl $0x8, %edi
callq 0x6200
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq %rax, (%rdi)
leaq 0x1e0e0(%rip), %rsi     # 0x284b0
xorl %eax, %eax
movl %eax, %edx
callq 0x66d0
jmp 0xa47f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x6690
jmp 0xa476
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
testb $0x1, 0xe0(%rax)
je 0xa470
movq 0x1ebdc(%rip), %rdi     # 0x28fe8
leaq 0x12e60(%rip), %rsi     # 0x1d273
callq 0x6410
movq %rax, -0x30(%rbp)
callq 0x6600
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x66f0
movq %rax, %rdi
leaq 0x12e44(%rip), %rsi     # 0x1d27a
callq 0x6410
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq 0x88(%rax), %rsi
addq $0x28, %rsi
callq 0x63a0
movq %rax, %rdi
leaq 0x12de1(%rip), %rsi     # 0x1d23d
callq 0x6410
movq %rax, %rdi
movq 0x1eb3d(%rip), %rsi     # 0x28fa8
callq 0x6460
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x6700
nop
// File: ryuichiueda[P]GlueLang/src/DefStr.cc
// Function: DefStr::readFifo()
bool DefStr::readFifo(void)
{
	try{
		m_data->readFifo();
	}catch(DataStr *e){
		m_error_msg = e->m_error_msg;
		m_exit_status = 3;
		throw this;
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0xa8(%rax), %rdi
callq 0x9a30
jmp 0xb542
jmp 0xb5ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xb5d4
movq -0x10(%rbp), %rdi
callq 0x6180
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
addq $0x60, %rdi
callq 0x6070
jmp 0xb583
movq -0x28(%rbp), %rax
movl $0x3, 0x80(%rax)
movl $0x8, %edi
callq 0x6200
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq %rax, (%rdi)
leaq 0x1cfe4(%rip), %rsi     # 0x28590
xorl %eax, %eax
movl %eax, %edx
callq 0x66d0
jmp 0xb5dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x6690
jmp 0xb5d4
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x6700
nopl (%rax)
// File: ryuichiueda[P]GlueLang/src/Element.cc
// Function: Element::Element(Feeder*, Environment*, std::vector<int, std::allocator<int>>*)
Element::Element(Feeder *f, Environment *env, vector<int> *scopes)
{
	m_feeder = f;	
	m_env = env;

	m_start_line = m_start_char = -1000;
	m_end_line = m_end_char = -1000;
	m_exit_status = 0;
	m_command_error = false;

	if(scopes == NULL){
		m_job_id = 0;
		m_scopes.push_back(0);
	}else{
		m_scopes = *scopes;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq 0x1cec9(%rip), %rax     # 0x285b0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x18, %rdi
movq %rdi, -0x58(%rbp)
callq 0xbb40
movq -0x40(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x50(%rbp)
callq 0xbb60
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x48(%rbp)
callq 0x65a0
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0xfffffc18, 0x34(%rax) # imm = 0xFFFFFC18
movl $0xfffffc18, 0x30(%rax) # imm = 0xFFFFFC18
movl $0xfffffc18, 0x3c(%rax) # imm = 0xFFFFFC18
movl $0xfffffc18, 0x38(%rax) # imm = 0xFFFFFC18
movl $0x0, 0x80(%rax)
movb $0x0, 0x84(%rax)
cmpq $0x0, -0x20(%rbp)
jne 0xb7b1
movq -0x40(%rbp), %rdi
movl $0x0, 0x40(%rdi)
addq $0x48, %rdi
movl $0x0, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
callq 0xbb80
jmp 0xb786
jmp 0xb7c6
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x6280
movq -0x50(%rbp), %rdi
callq 0xbe00
movq -0x58(%rbp), %rdi
callq 0xbe60
jmp 0xb7cc
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x48, %rdi
callq 0xbbb0
jmp 0xb7c4
jmp 0xb7c6
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x6700
nopw %cs:(%rax,%rax)
// File: ryuichiueda[P]GlueLang/src/Element.cc
// Function: Element::add(Element*)
bool Element::add(Element *n)
{
	if( n->parse() ){
		m_nodes.push_back(n);
		return true;
	}
	delete n;
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb $0x1, %al
jne 0xb888
jmp 0xb89f
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
leaq -0x18(%rbp), %rsi
callq 0xbec0
movb $0x1, -0x1(%rbp)
jmp 0xb8bb
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xb8b7
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ryuichiueda[P]GlueLang/src/Element.cc
// Function: Element::setJobId(int)
void Element::setJobId(int id)
{
	m_job_id = id;
	m_scopes.push_back(id);
	for(auto &n : m_nodes){
		n->m_job_id = id;
		n->setJobId(id);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0xc(%rbp), %eax
movl %eax, 0x40(%rdi)
addq $0x48, %rdi
leaq -0xc(%rbp), %rsi
callq 0xbfa0
movq -0x38(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xc010
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xc040
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xc070
testb $0x1, %al
jne 0xbb03
jmp 0xbb38
leaq -0x20(%rbp), %rdi
callq 0xc0b0
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %ecx
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl %ecx, 0x40(%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *0x30(%rax)
leaq -0x20(%rbp), %rdi
callq 0xc0d0
jmp 0xbaf0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: ryuichiueda[P]GlueLang/src/Environment.cc
// Function: Environment::initExecProc(char const**)
void Environment::initExecProc(char const* argv[])
{
	m_pid = getpid();
	//set args
	int c = 0;
	m_args.clear();
	while(argv[c] != NULL){
		m_args.push_back(argv[c]);
		c++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x6600
movq -0x58(%rbp), %rdi
movl %eax, 0xe4(%rdi)
movl $0x0, -0x14(%rbp)
callq 0xf650
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xe1f8
movq -0x58(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x68(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x6710
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x7940
jmp 0xe19e
movq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xf440
jmp 0xe1ad
leaq -0x38(%rbp), %rdi
callq 0x6280
leaq -0x39(%rbp), %rdi
callq 0x6480
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xe153
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xe1ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6280
leaq -0x39(%rbp), %rdi
callq 0x6480
jmp 0xe1fe
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x6700
nopw (%rax,%rax)
// File: ryuichiueda[P]GlueLang/src/Environment.cc
// Function: Environment::setImportPath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
void Environment::setImportPath(string *key, string *value)
{
	string path;
	if(value->at(0) == '/'){
		path = *value;
	}else{
		path = m_dir + "/" + *value; //resolve relative path (too lazy)
	}
	m_import_paths[*key].push_back(path);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x65a0
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6770
movq %rax, -0x90(%rbp)
jmp 0xe5c1
movq -0x90(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0xe5f5
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x6070
jmp 0xe5df
jmp 0xe669
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xe6aa
movq -0x98(%rbp), %rsi
addq $0x48, %rsi
leaq 0xefb3(%rip), %rdx      # 0x1d5ba
leaq -0x88(%rbp), %rdi
callq 0x79f0
jmp 0xe615
movq -0x18(%rbp), %rdx
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x8720
jmp 0xe62b
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x6520
leaq -0x68(%rbp), %rdi
callq 0x6280
leaq -0x88(%rbp), %rdi
callq 0x6280
jmp 0xe669
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x6280
jmp 0xe6aa
movq -0x98(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
callq 0xf670
movq %rax, -0xa0(%rbp)
jmp 0xe686
movq -0xa0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xf750
jmp 0xe698
leaq -0x38(%rbp), %rdi
callq 0x6280
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x6280
movq -0x40(%rbp), %rdi
callq 0x6700
nopl (%rax)
// File: ryuichiueda[P]GlueLang/src/Environment.cc
// Function: Environment::getPATH[abi:cxx11]()
string Environment::getPATH(void)
{
	string ans = "PATH=";
	for(auto &path : m_import_paths[""]){
		ans += path + ":";
	}
	ans.pop_back();
	return ans;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x6710
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rdx
leaq 0xecc9(%rip), %rsi      # 0x1d451
callq 0x7940
jmp 0xe78f
leaq -0x12(%rbp), %rdi
callq 0x6480
movq -0xa8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0xc0(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x6710
movq -0xb8(%rbp), %rdx
leaq 0xf023(%rip), %rsi      # 0x1d7eb
leaq -0x50(%rbp), %rdi
callq 0x7940
jmp 0xe7d3
movq -0xc0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xf850
movq %rax, -0xc8(%rbp)
jmp 0xe7ec
leaq -0x50(%rbp), %rdi
callq 0x6280
leaq -0x51(%rbp), %rdi
callq 0x6480
movq -0xc8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x7af0
movq %rax, -0x60(%rbp)
movq -0x30(%rbp), %rdi
callq 0x7b20
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x7b50
testb $0x1, %al
jne 0xe839
jmp 0xe8fb
leaq -0x60(%rbp), %rdi
callq 0x7b90
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rsi
leaq 0xec06(%rip), %rdx      # 0x1d457
leaq -0x90(%rbp), %rdi
callq 0x79f0
jmp 0xe85f
movq -0xa0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x6560
jmp 0xe874
leaq -0x90(%rbp), %rdi
callq 0x6280
leaq -0x60(%rbp), %rdi
callq 0x7bb0
jmp 0xe823
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x6480
jmp 0xe939
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xe8c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x6280
leaq -0x51(%rbp), %rdi
callq 0x6480
jmp 0xe92d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xe92d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x6280
jmp 0xe92d
movq -0xa0(%rbp), %rdi
callq 0x6510
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xe91d
movq -0xa0(%rbp), %rdi
callq 0x6280
movq -0xb0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x6280
movq -0x20(%rbp), %rdi
callq 0x6700
nopw %cs:(%rax,%rax)
// File: ryuichiueda[P]GlueLang/src/Environment.cc
// Function: Environment::getData(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
Data *Environment::getData(int scope_id,string *key)
{
	string k = genKey(scope_id,key);
	//cerr << "get: " << k << endl;
	if(m_data.find(k) == m_data.end()){
		m_error_msg = "Variable " + *key + " not found";
		throw this;
	}

	return m_data[k];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xb0(%rbp)
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
leaq -0x38(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xeb50
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
addq $0x68, %rdi
callq 0xf990
movq %rax, -0xa0(%rbp)
jmp 0xe9f8
movq -0xb0(%rbp), %rdi
movq -0xa0(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x68, %rdi
callq 0xf540
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xf960
testb $0x1, %al
jne 0xea2d
jmp 0xeae9
movq -0x18(%rbp), %rdx
leaq 0xea21(%rip), %rsi      # 0x1d459
leaq -0x98(%rbp), %rdi
callq 0x7c20
jmp 0xea46
leaq 0xea16(%rip), %rdx      # 0x1d463
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x7bd0
jmp 0xea5f
movq -0xb0(%rbp), %rdi
addq $0xa0, %rdi
leaq -0x78(%rbp), %rsi
movq %rsi, -0xb8(%rbp)
callq 0x6520
movq -0xb8(%rbp), %rdi
callq 0x6280
leaq -0x98(%rbp), %rdi
callq 0x6280
movl $0x8, %edi
callq 0x6200
movq %rax, %rdi
movq -0xb0(%rbp), %rax
movq %rax, (%rdi)
leaq 0x197bd(%rip), %rsi     # 0x28270
xorl %eax, %eax
movl %eax, %edx
callq 0x66d0
jmp 0xeb42
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xeb30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x6280
jmp 0xeb30
movq -0xb0(%rbp), %rdi
addq $0x68, %rdi
leaq -0x38(%rbp), %rsi
callq 0xf9c0
movq %rax, -0xc0(%rbp)
jmp 0xeb06
movq -0xc0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc8(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6280
movq -0xc8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x6280
movq -0x48(%rbp), %rdi
callq 0x6700
nopw %cs:(%rax,%rax)