LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/alfanick[P]rest-cpp/src/rest/worker.cpp
// Function: REST::Worker::run()
void Worker::run() {
  should_run = true;

  thread = std::thread([this] () {
    THREAD_NAME(server_header.c_str());

    // while worker is alive
    while (should_run) {
      Request::client client;

      clients_queue.wait_dequeue(client);

      // make request
      Request request(client.handle, client.address);

      if (!should_run)
        break;

      Response response(request, streamers);
      response.headers["Server"] = server_header + ", waiting " + std::to_string(clients_count);

      try {
        request.process();

        make_action(request, response);
      } catch (HTTP::Error &e) {
        response.error(e);
      }

      response.send();

      clear_streamers();

      clients_count--;
      total_clients_count++;
    }

    std::cout << "Stopped worker #" << id << " with " << clients_count << " clients in queue (processed " << total_clients_count << ")" << std::endl;
  });
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movb $0x1, 0x34(%rdi)
leaq 0x10(%rsp), %r14
movq $0x0, (%r14)
movl $0x10, %edi
callq 0x22250
leaq 0x1521f(%rip), %rcx     # 0x4d530
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
xorl %edx, %edx
callq 0x22050
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3833a
movq (%rdi), %rax
callq *0x8(%rax)
cmpq $0x0, 0x40(%rbx)
jne 0x38352
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x213c0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3836a
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x23170
nop
// File: /workspace/github_cpp_makefile_star2_O1/alfanick[P]rest-cpp/src/rest/worker.cpp
// Function: REST::Worker::make_action(REST::Request&, REST::Response&)
void Worker::make_action(Request &request, Response &response) {
  Service* service = Router::find(request, id);

  if (service == nullptr)
    throw HTTP::NotFound();

  service->request = &request;
  service->response = &response;

  service->make_action();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl 0x30(%rdi), %esi
movq %r14, %rdi
callq 0x22b10
testq %rax, %rax
je 0x383d5
movq %r14, 0x10(%rax)
movq %rbx, 0x8(%rax)
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x227b0
movl $0x8, %edi
callq 0x217b0
movq 0x158ba(%rip), %rcx     # 0x4dca0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x15b0c(%rip), %rsi     # 0x4df00
movq 0x15bbd(%rip), %rdx     # 0x4dfb8
movq %rax, %rdi
callq 0x230a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/alfanick[P]rest-cpp/src/rest/worker.cpp
// Function: REST::Worker::stop()
void Worker::stop() {
  should_run = false;
  clear_streamers();
  Request::client c;
  clients_queue.enqueue(c);
  thread.join();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movb $0x0, 0x34(%rdi)
movq 0x50(%rdi), %r15
movq 0x48(%rdi), %r14
movq %r15, %rax
subq %r14, %rax
sarq $0x3, %rax
movl 0x38(%rdi), %ecx
cmpq %rcx, %rax
jb 0x38467
cmpq %r15, %r14
je 0x38444
movq %r14, %rdi
callq 0x23090
addq $0x8, %r14
jmp 0x38431
movq 0x48(%rbx), %rax
movq 0x50(%rbx), %rcx
cmpq %rax, %rcx
je 0x38467
movq %rax, %rdx
cmpq $0x0, (%rdx)
jne 0x384a3
addq $0x8, %rdx
cmpq %rcx, %rdx
jne 0x38454
movq %rax, 0x50(%rbx)
leaq 0x60(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x21ea0
testb %al, %al
je 0x3848a
leaq 0xb8(%rbx), %rdi
movl $0x1, %esi
callq 0x22c00
addq $0x40, %rbx
movq %rbx, %rdi
callq 0x23090
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x213c0
// File: /workspace/github_cpp_makefile_star2_O1/alfanick[P]rest-cpp/src/rest/readerwriterqueue/readerwriterqueue.h
// Function: moodycamel::ReaderWriterQueue<REST::Request::client, 512ul>::make_block(unsigned long)
static Block* make_block(size_t capacity)
	{
		// Allocate enough memory for the block itself, as well as all the elements it will contain
		auto size = sizeof(Block) + std::alignment_of<Block>::value - 1;
		size += sizeof(T) * capacity + std::alignment_of<T>::value - 1;
		auto newBlockRaw = static_cast<char*>(std::malloc(size));
		if (newBlockRaw == nullptr) {
			return nullptr;
		}
		
		auto newBlockAligned = align_for<Block>(newBlockRaw);
		auto newBlockData = align_for<T>(newBlockAligned + sizeof(Block));
		return new (newBlockAligned) Block(capacity, newBlockRaw, newBlockData);
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rdi, %rax
shlq $0x7, %rax
leaq 0xae(%rax,%rdi,8), %rdi
callq 0x227d0
testq %rax, %rax
je 0x38d8d
movl %eax, %edx
negl %edx
andl $0x7, %edx
leaq 0xa0(%rax,%rdx), %rsi
movq %rax, %rcx
addq %rdx, %rcx
negl %esi
andl $0x7, %esi
leaq 0xa0(%rsi,%rcx), %rsi
movq $0x0, 0x80(%rax,%rdx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, (%rax,%rdx)
vmovups %xmm0, 0x40(%rax,%rdx)
movq %rsi, 0x88(%rax,%rdx)
decq %rbx
movq %rbx, 0x90(%rax,%rdx)
movq %rax, 0x98(%rax,%rdx)
jmp 0x38d8f
xorl %ecx, %ecx
movq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/alfanick[P]rest-cpp/src/rest/readerwriterqueue/atomicops.h
// Function: moodycamel::spsc_sema::LightweightSemaphore::signal(long)
void signal(ssize_t count = 1)
		    {
		    	assert(count >= 0);
		        ssize_t oldCount = m_count.fetch_add_release(count);
		        assert(oldCount >= -1);
		        if (oldCount < 0)
		        {
		            m_sema.signal(1);
		        }
		    }

// Assembly:
pushq %rax
testq %rsi, %rsi
js 0x38dd2
lock
xaddq %rsi, (%rdi)
cmpq $-0x2, %rsi
jle 0x38df1
testq %rsi, %rsi
js 0x38dc8
popq %rax
retq
addq $0x8, %rdi
popq %rax
jmp 0x23020
leaq 0x780f(%rip), %rdi      # 0x405e8
leaq 0x754c(%rip), %rsi      # 0x4032c
leaq 0x780c(%rip), %rcx      # 0x405f3
movl $0x22a, %edx            # imm = 0x22A
callq 0x21b40
leaq 0x783d(%rip), %rdi      # 0x40635
leaq 0x752d(%rip), %rsi      # 0x4032c
leaq 0x77ed(%rip), %rcx      # 0x405f3
movl $0x22c, %edx            # imm = 0x22C
callq 0x21b40
// File: /workspace/github_cpp_makefile_star2_O1/alfanick[P]rest-cpp/src/rest/readerwriterqueue/readerwriterqueue.h
// Function: bool moodycamel::ReaderWriterQueue<REST::Request::client, 512ul>::inner_enqueue<(moodycamel::ReaderWriterQueue<REST::Request::client, 512ul>::AllocationMode)0, REST::Request::client const&>(REST::Request::client const&)
ReentrantGuard(bool& _inSection)
			: inSection(_inSection)
		{
			assert(!inSection);
			if (inSection) {
				throw std::runtime_error("ReaderWriterQueue does not support enqueuing or dequeuing elements from other elements' ctors and dtors");
			}

			inSection = true;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x1, 0x50(%rdi)
je 0x38fcd
movq %rsi, %r14
movq %rdi, %rbx
movb $0x1, 0x50(%rdi)
movq 0x40(%rdi), %r12
movq 0x40(%r12), %rcx
leaq 0x1(%rcx), %rax
andq 0x90(%r12), %rax
cmpq 0x48(%r12), %rax
jne 0x38f00
movq (%r12), %rdx
movq %rdx, 0x48(%r12)
cmpq %rdx, %rax
jne 0x38f00
movq 0x80(%r12), %rax
movq (%rbx), %rcx
cmpq %rcx, %rax
jne 0x38f45
movq 0x48(%rbx), %rax
cmpq $0x200, %rax            # imm = 0x200
setb %cl
shlxq %rcx, %rax, %r15
movq %r15, %rdi
callq 0x22d10
testq %rax, %rax
je 0x38fc9
movq %r15, 0x48(%rbx)
movq 0x88(%rax), %rcx
movq 0x80(%r14), %rdx
movq %rdx, 0x80(%rcx)
vmovups (%r14), %zmm0
vmovups 0x40(%r14), %zmm1
vmovups %zmm1, 0x40(%rcx)
vmovups %zmm0, (%rcx)
movq (%rax), %rcx
testq %rcx, %rcx
jne 0x3900b
movq $0x1, 0x8(%rax)
movq $0x1, 0x40(%rax)
movq 0x80(%r12), %rcx
movq %rcx, 0x80(%rax)
movq %rax, 0x80(%r12)
jmp 0x38fb0
movq 0x88(%r12), %rdx
movq %rcx, %rsi
shlq $0x7, %rsi
leaq (%rsi,%rcx,8), %rcx
movq 0x80(%r14), %rsi
movq %rsi, 0x80(%rdx,%rcx)
vmovups (%r14), %zmm0
vmovups 0x40(%r14), %zmm1
vmovups %zmm1, 0x40(%rdx,%rcx)
vmovups %zmm0, (%rdx,%rcx)
movq %rax, 0x40(%r12)
jmp 0x38fb4
movq 0x80(%r12), %rax
movq (%rax), %rdx
movq %rdx, 0x48(%rax)
movq 0x40(%rax), %rcx
cmpq %rcx, %rdx
jne 0x38fec
movq %rdx, 0x48(%rax)
movq %rcx, %rdx
shlq $0x7, %rdx
leaq (%rdx,%rcx,8), %rdx
movq 0x88(%rax), %rsi
movq 0x80(%r14), %rdi
movq %rdi, 0x80(%rsi,%rdx)
vmovups (%r14), %zmm0
vmovups 0x40(%r14), %zmm1
vmovups %zmm1, 0x40(%rsi,%rdx)
vmovups %zmm0, (%rsi,%rdx)
incq %rcx
andq 0x90(%rax), %rcx
movq %rcx, 0x40(%rax)
movq %rax, 0x40(%rbx)
movb $0x1, %al
movb $0x0, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
vzeroupper
retq
xorl %eax, %eax
jmp 0x38fb6
leaq 0x757a(%rip), %rdi      # 0x4054e
leaq 0x738e(%rip), %rsi      # 0x40369
leaq 0x7577(%rip), %rcx      # 0x40559
movl $0x222, %edx            # imm = 0x222
callq 0x21b40
leaq 0x7437(%rip), %rdi      # 0x4042a
leaq 0x736f(%rip), %rsi      # 0x40369
leaq 0x7449(%rip), %rcx      # 0x4044a
movl $0x1cb, %edx            # imm = 0x1CB
callq 0x21b40
leaq 0x7527(%rip), %rdi      # 0x40539
leaq 0x7350(%rip), %rsi      # 0x40369
leaq 0x742a(%rip), %rcx      # 0x4044a
movl $0x1e2, %edx            # imm = 0x1E2
vzeroupper
callq 0x21b40
movb $0x0, 0x50(%rbx)
movq %rax, %rdi
callq 0x23170
nop
// File: /workspace/github_cpp_makefile_star2_O1/alfanick[P]rest-cpp/src/rest/readerwriterqueue/readerwriterqueue.h
// Function: void moodycamel::BlockingReaderWriterQueue<REST::Request::client, 512ul>::wait_dequeue<REST::Request::client>(REST::Request::client&)
void wait_dequeue(U& result)
	{
		sema.wait();
		bool success = inner.try_dequeue(result);
		AE_UNUSED(result);
		assert(success);
		AE_UNUSED(success);
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x58, %rdi
movq 0x58(%r14), %rax
testq %rax, %rax
jle 0x39057
lock
decq (%rdi)
jmp 0x3905c
callq 0x21780
movq %r14, %rdi
movq %rbx, %rsi
callq 0x224f0
testb %al, %al
je 0x39073
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x760b(%rip), %rdi      # 0x40685
leaq 0x72e8(%rip), %rsi      # 0x40369
leaq 0x7605(%rip), %rcx      # 0x4068d
movl $0x2c9, %edx            # imm = 0x2C9
callq 0x21b40
// File: /workspace/github_cpp_makefile_star2_O1/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>::empty() const
bool empty() const noexcept
    {
        switch (m_type)
        {
            case value_t::null:
            {
                // null values are empty
                return true;
            }

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

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

            default:
            {
                // all other types are nonempty
                return false;
            }
        }
    }

// Assembly:
pushq %rax
movzbl (%rdi), %eax
testl %eax, %eax
je 0x3b20d
cmpl $0x1, %eax
je 0x3b1fa
cmpl $0x2, %eax
jne 0x3b211
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x3b234
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
jmp 0x3b208
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x3b215
cmpq $0x0, 0x28(%rax)
sete %al
jmp 0x3b213
movb $0x1, %al
jmp 0x3b213
xorl %eax, %eax
popq %rcx
retq
leaq 0x398f(%rip), %rdi      # 0x3ebab
leaq 0x301f(%rip), %rsi      # 0x3e242
leaq 0x5b7d(%rip), %rcx      # 0x40da7
movl $0xfe3, %edx            # imm = 0xFE3
callq 0x21b40
leaq 0x3ae9(%rip), %rdi      # 0x3ed24
leaq 0x3000(%rip), %rsi      # 0x3e242
leaq 0x5b5e(%rip), %rcx      # 0x40da7
movl $0xfdd, %edx            # imm = 0xFDD
callq 0x21b40
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x21c30
xorl %edx, %edx
testl %ebp, %ebp
setns %dl
leaq 0x18(%rsp), %rsi
movl %ebp, %eax
sarl $0x1f, %eax
andnl %ebp, %eax, %ecx
movq %r14, %rdi
xorl %r8d, %r8d
callq 0x210c0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x22dc0
movq 0x129aa(%rip), %rsi     # 0x4dc50
leaq 0x8(%rsp), %rdi
callq 0x21ca0
leaq 0x88(%rsp), %rdi
callq 0x21510
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x1297a(%rip), %rsi     # 0x4dc50
leaq 0x8(%rsp), %rdi
callq 0x21ca0
leaq 0x88(%rsp), %rdi
callq 0x21510
movq %rbx, %rdi
callq 0x23170
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rax
movzbl (%rdi), %eax
testl %eax, %eax
je 0x3bc8e
cmpl $0x1, %eax
je 0x3bc7a
cmpl $0x2, %eax
jne 0x3bc89
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x3bcaf
movq 0x8(%rcx), %rax
subq (%rcx), %rax
sarq $0x4, %rax
jmp 0x3bc8e
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x3bc90
movq 0x28(%rax), %rax
jmp 0x3bc8e
movl $0x1, %eax
popq %rcx
retq
leaq 0x2f14(%rip), %rdi      # 0x3ebab
leaq 0x25a4(%rip), %rsi      # 0x3e242
leaq 0x4f11(%rip), %rcx      # 0x40bb6
movl $0x101d, %edx           # imm = 0x101D
callq 0x21b40
leaq 0x306e(%rip), %rdi      # 0x3ed24
leaq 0x2585(%rip), %rsi      # 0x3e242
leaq 0x4ef2(%rip), %rcx      # 0x40bb6
movl $0x1017, %edx           # imm = 0x1017
callq 0x21b40
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpb $0x2, (%rdi)
jne 0x3bcfa
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x3bd4e
shlq $0x4, %rsi
addq (%rax), %rsi
movq %rsi, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x217b0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0x22850
leaq 0x2ab1(%rip), %rsi      # 0x3e7ca
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x22ff0
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x225e0
xorl %ebp, %ebp
movq 0x11f89(%rip), %rsi     # 0x4dcc8
movq 0x12062(%rip), %rdx     # 0x4dda8
movq %rbx, %rdi
callq 0x230a0
leaq 0x2fcf(%rip), %rdi      # 0x3ed24
leaq 0x24e6(%rip), %rsi      # 0x3e242
leaq 0x4f41(%rip), %rcx      # 0x40ca4
movl $0xb96, %edx            # imm = 0xB96
callq 0x21b40
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3bd8b
callq 0x22130
jmp 0x3bd8b
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3bda6
callq 0x22130
jmp 0x3bda6
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x3bdb3
movq %rbx, %rdi
callq 0x21c50
movq %r14, %rdi
callq 0x23170
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, (%rdi)
movb $0x1, 0x8(%rdi)
xorl %edi, %edi
callq 0x22090
movl %eax, %edi
callq 0x22170
movl $0x1, %esi
movl $0xd, %edi
callq 0x22570
movq 0x11b39(%rip), %rax     # 0x4dfa0
movb (%rax), %al
testb %al, %al
je 0x3c4c8
movq (%rbx), %rdi
callq 0x21760
movl $0x1, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x21350
movl %eax, %ebp
movl %eax, 0x48(%r14)
leaq 0x4(%rsp), %r14
movw $0x1, -0x2(%r14)
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x220d0
movq %r14, %rdi
callq 0x21710
leal 0x3(%rax), %edx
leaq 0x2(%rsp), %rsi
movl %ebp, %edi
callq 0x211b0
cmpl $-0x1, %eax
je 0x3c50f
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x11ad1(%rip), %rdi     # 0x4dfa0
callq 0x231e0
testl %eax, %eax
je 0x3c46d
movq 0x11ae9(%rip), %rdi     # 0x4dfc8
callq 0x231c0
movq 0x1176d(%rip), %rdi     # 0x4dc58
movq 0x11ad6(%rip), %rsi     # 0x4dfc8
leaq 0x12da7(%rip), %rdx     # 0x4f2a0
callq 0x21fa0
movq 0x11a9b(%rip), %rdi     # 0x4dfa0
callq 0x21b30
jmp 0x3c46d
movl $0x8, %edi
callq 0x217b0
movq 0x11700(%rip), %rcx     # 0x4dc20
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x117a2(%rip), %rsi     # 0x4dcd0
movq 0x11a83(%rip), %rdx     # 0x4dfb8
movq %rax, %rdi
callq 0x230a0
movq %rax, %rbx
movq 0x11a59(%rip), %rdi     # 0x4dfa0
callq 0x21ac0
movq %rbx, %rdi
callq 0x23170
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbx
movq %rdi, %rbx
movb $0x0, 0x8(%rdi)
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x3c7f2
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x40(%rbx), %rdi
callq 0x22740
movl 0x48(%rbx), %edi
callq 0x23470
popq %rbx
retq
movq %rax, %rdi
callq 0x249b5
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
callq 0x21650
movq %rax, %rdi
callq 0x21d00
movl 0x48(%rbx), %edi
movl $0x1000, %esi           # imm = 0x1000
callq 0x22450
cmpl $-0x1, %eax
je 0x3c947
cmpb $0x1, 0x8(%rbx)
jne 0x3c935
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %r15
movq 0x11408(%rip), %r13     # 0x4dc68
addq $0x10, %r13
movq 0x1177d(%rip), %rbp     # 0x4dfe8
leaq 0x46ee(%rip), %r12      # 0x40f60
movl $0x80, 0xc(%rsp)
movl 0x48(%rbx), %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x21480
movl %eax, 0x90(%rsp)
cmpl $-0x1, %eax
je 0x3c8aa
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x23230
cmpb $0x0, 0x8(%rbx)
jne 0x3c872
jmp 0x3c935
movl $0x8, %edi
callq 0x217b0
movq %r13, (%rax)
movq %rax, %rdi
movq 0x11387(%rip), %rsi     # 0x4dc48
movq 0x116f0(%rip), %rdx     # 0x4dfb8
callq 0x230a0
jmp 0x3c975
movq %rax, (%rsp)
cmpl $0x1, %edx
jne 0x3c97e
movq (%rsp), %rdi
callq 0x21630
movq %rax, (%rsp)
cmpb $0x1, 0x8(%rbx)
jne 0x3c91f
movl $0x4, %edx
movq %rbp, %rdi
movq %r12, %rsi
callq 0x22480
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rbp, %rdi
movq %rax, %rsi
callq 0x22240
movq %rax, %rdi
callq 0x217a0
movl 0x90(%rsp), %edi
callq 0x23470
callq 0x22ee0
jmp 0x3c89f
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x217b0
movq 0x11310(%rip), %rcx     # 0x4dc68
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x112e2(%rip), %rsi     # 0x4dc48
movq 0x1164b(%rip), %rdx     # 0x4dfb8
movq %rax, %rdi
callq 0x230a0
movq %rax, (%rsp)
callq 0x22ee0
movq (%rsp), %rdi
callq 0x23170
movq %rax, %rdi
callq 0x249b5
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %rax
movq 0x10(%rdi), %rdi
movq %rax, 0x8(%rsp)
leaq 0xc8(%rax), %rsi
callq 0xb138
testq %rax, %rax
je 0x72c8
movq (%rax), %r14
movq %rax, 0x30(%rsp)
movq 0x8(%rax), %rbx
cmpq %rbx, %r14
je 0x71fc
movq 0x8(%rsp), %rax
leaq 0x88(%rax), %r15
leaq 0xa8(%rax), %r12
leaq 0x10(%rsp), %r13
leaq 0x38(%rsp), %rbp
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x7456
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x7321
movq %r12, %rdi
movq %rbp, %rsi
callq 0x63f0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x71bd
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x6330
movq (%r12), %rdi
leaq 0x58(%rsp), %rsi
callq 0x62b0
testl %eax, %eax
je 0x7291
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x71ef
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6330
addq $0x20, %r14
cmpq %rbx, %r14
jne 0x716c
movq 0x8(%rsp), %rax
leaq 0x88(%rax), %rdx
leaq 0xce0f(%rip), %rsi      # 0x1401e
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x73ce
leaq 0xce04(%rip), %rdx      # 0x14027
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x737b
movq 0x8(%rsp), %rbx
leaq 0x60(%rbx), %rdi
leaq 0x10(%rsp), %r14
movq %r14, %rsi
callq 0x63f0
movq %r14, %rdi
callq 0x6150
leaq 0x38(%rsp), %rdi
callq 0x6150
movl $0x2, 0x80(%rbx)
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
leaq 0x3c(%rbx), %rdx
callq 0x1003e
movl $0x8, %edi
callq 0x6190
movq %rbx, (%rax)
leaq 0x13d99(%rip), %rsi     # 0x1b020
movq %rax, %rdi
xorl %edx, %edx
callq 0x6550
movq 0x8(%rsp), %rdx
movq 0x8(%rdx), %rdi
leaq 0x38(%rdx), %rsi
addq $0x3c, %rdx
callq 0x1003e
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x72c3
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6330
movq 0x30(%rsp), %rax
testq %rax, %rax
setne %al
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x72fa
movq %rax, %r14
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7319
movq 0x48(%rsp), %rsi
jmp 0x7311
movq %rax, %r14
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x7319
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6330
movq %r14, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x30(%rbx), %rsi
leaq 0x34(%rbx), %rdx
callq 0x1003e
movq 0x8(%rbx), %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xca92(%rip), %rsi      # 0x14073
leaq 0xca8e(%rip), %rdx      # 0x14076
movq %rsp, %r15
movq %r15, %rdi
callq 0x74e6
movq %r14, %rdi
movq %r15, %rsi
callq 0x100e8
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x7614
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6330
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0x8(%rbx), %rdi
leaq 0xa8(%rbx), %r14
movq %r14, %rsi
callq 0xf7a4
testb %al, %al
je 0x76bd
leaq 0xca29(%rip), %rsi      # 0x14073
leaq 0x40(%rsp), %rdi
movq %r14, %rdx
callq 0x73ce
leaq 0x88(%rbx), %rdi
leaq 0x40(%rsp), %r15
movq %r15, %rsi
callq 0x63f0
movq (%r15), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x7685
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x6330
leaq 0xcecf(%rip), %rsi      # 0x1455b
movq %r14, %rdi
callq 0x60f0
testl %eax, %eax
je 0x76a4
movq %r14, %rdi
callq 0x11220
testb %al, %al
je 0x76bd
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
addq $0x3c, %rbx
movb $0x1, %bpl
movq %rbx, %rdx
callq 0x1003e
jmp 0x76ce
movq 0x8(%rbx), %rdi
movl 0x30(%rbx), %esi
movl 0x34(%rbx), %edx
callq 0xf958
xorl %ebp, %ebp
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x76e5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6330
movl %ebp, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7709
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x7723
movq 0x10(%rsp), %rsi
jmp 0x771b
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x7723
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x30(%rbx), %rsi
leaq 0x34(%rbx), %rdx
callq 0x1003e
movq 0x8(%rbx), %r14
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xc644(%rip), %rsi      # 0x14091
leaq 0xc643(%rip), %rdx      # 0x14097
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x74e6
movq %r14, %rdi
movq %r15, %rsi
callq 0x100e8
movl %eax, %ebp
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x7a85
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6330
testb %bpl, %bpl
je 0x7a93
movb $0x1, 0xc8(%rbx)
jmp 0x7ae9
movq 0x8(%rbx), %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xc5da(%rip), %rsi      # 0x14082
leaq 0xc5d8(%rip), %rdx      # 0x14087
movq %rsp, %r15
movq %r15, %rdi
callq 0x74e6
movq %r14, %rdi
movq %r15, %rsi
callq 0x100e8
movl %eax, %ebp
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x7add
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6330
testb %bpl, %bpl
je 0x7ae9
movb $0x1, 0xc9(%rbx)
movq 0x8(%rbx), %rdi
leaq 0x88(%rbx), %r14
movq %r14, %rsi
callq 0xf7a4
movl %eax, %ebp
testb %al, %al
je 0x7b5b
cmpb $0x1, 0xc8(%rbx)
jne 0x7b47
leaq 0xc57f(%rip), %rsi      # 0x14091
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x73ce
movq %r14, %rdi
movq %r15, %rsi
callq 0x63f0
movq (%r15), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x7b47
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x6330
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
addq $0x3c, %rbx
movq %rbx, %rdx
callq 0x1003e
movl %ebp, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0x7b7b
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x7b8c
movq (%r12), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
leaq 0x48(%rbx), %rsi
leaq 0x88(%rbx), %rdx
callq 0xb626
addq $0x28, %rax
leaq 0xa8(%rbx), %rdi
movq %rax, %rsi
callq 0x61c0
movb $0x1, %al
popq %rbx
retq
movq %rax, %rdi
callq 0x6130
movl $0xa0, %esi
addq 0x10(%rbx), %rsi
leaq 0x60(%rbx), %rdi
callq 0x61c0
movl $0x3, 0x80(%rbx)
movl $0x8, %edi
callq 0x6190
movq %rbx, (%rax)
leaq 0x13595(%rip), %rsi     # 0x1b190
movq %rax, %rdi
xorl %edx, %edx
callq 0x6550
movq %rax, %rbx
callq 0x6500
movq %rbx, %rdi
callq 0x6580
movq %rax, %rdi
callq 0x7c1d
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x30(%rbx), %rsi
leaq 0x34(%rbx), %rdx
callq 0x1003e
movq 0x8(%rbx), %rdi
leaq 0x88(%rbx), %rsi
leaq 0xc8(%rbx), %rdx
callq 0xf672
movl %eax, %ebp
testb %al, %al
je 0x7ca5
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
addq $0x3c, %rbx
movq %rbx, %rdx
callq 0x1003e
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0x7d10
movq %r14, %rdi
callq 0x6130
movq %rax, %r14
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
leaq 0x3c(%rbx), %rdx
callq 0x1003e
addq $0x28, %r14
leaq 0x60(%rbx), %rdi
movq %r14, %rsi
callq 0x61c0
movl $0x3, 0x80(%rbx)
movl $0x8, %edi
callq 0x6190
movq %rbx, (%rax)
leaq 0x13552(%rip), %rsi     # 0x1b250
movq %rax, %rdi
xorl %edx, %edx
callq 0x6550
movq %rax, %r14
callq 0x6500
movq %r14, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzbl 0x48(%rdi), %esi
shll $0xa, %esi
orl $0x41, %esi
movq 0x28(%rdi), %rdi
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x6210
cmpl $0x2, %eax
jle 0x8204
movl %eax, %ebp
movl %eax, %edi
movl $0x1, %esi
callq 0x62d0
testl %eax, %eax
js 0x81f7
movl %ebp, %edi
callq 0x65e0
testl %eax, %eax
js 0x81f7
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x8(%rbx), %rdi
leaq 0xbff1(%rip), %rsi      # 0x141f3
jmp 0x820f
leaq 0x8(%rbx), %rdi
leaq 0xbfd0(%rip), %rsi      # 0x141df
callq 0x6410
movl $0x8, %edi
callq 0x6190
movq %rbx, (%rax)
leaq 0x13100(%rip), %rsi     # 0x1b328
movq %rax, %rdi
xorl %edx, %edx
callq 0x6550
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
movl $0x1, %esi
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x6210
movl %eax, %ebp
movl %eax, %edi
movl $0x1, %esi
callq 0x62d0
testl %eax, %eax
js 0x8421
movl %ebp, %edi
callq 0x65e0
testl %eax, %eax
js 0x8421
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x8(%rbx), %rdi
leaq 0xbe1a(%rip), %rsi      # 0x14246
callq 0x6410
movl $0x8, %edi
callq 0x6190
movq %rbx, (%rax)
leaq 0x12fdb(%rip), %rsi     # 0x1b420
movq %rax, %rdi
xorl %edx, %edx
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
movq %rdi, %rbx
movq 0x48(%rdi), %rsi
leaq 0x60(%rsp), %rdi
movl $0x8, %edx
callq 0x65b0
leaq 0x30(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x10(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
cmpb $0x1, 0x68(%rbx)
jne 0x84b6
leaq 0xc491(%rip), %rcx      # 0x14935
movq %rsp, %rdi
movl $0x1, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x64c0
movq 0x60(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x80(%rsp,%rax)
jne 0x8588
leaq (%rsp,%rax), %rdi
addq $0x60, %rdi
movb $0x1, %r13b
leaq 0x60(%rsp), %r14
leaq 0x20(%rsp), %r15
movq %rsp, %r12
leaq 0x40(%rsp), %rbp
movl $0xa, %esi
callq 0x6300
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x65c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x8588
testb $0x1, %r13b
je 0x852d
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %r12, %rdi
callq 0x6100
xorl %r13d, %r13d
jmp 0x856d
movq %rbp, %rdi
leaq 0xc3fe(%rip), %rsi      # 0x14935
movq %r15, %rdx
callq 0x73ce
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq %r12, %rdi
callq 0x6100
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x856d
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x6330
movq 0x60(%rsp), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %rdi
addq $0x60, %rdi
testb $0x5, 0x20(%rdi)
je 0x84ea
movb $0x1, 0x68(%rbx)
addq $0x28, %rbx
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x6100
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x85bc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6330
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x85d8
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6330
leaq 0x60(%rsp), %rdi
callq 0x60b0
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x861b
jmp 0x861b
movq %rax, %rbx
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x861e
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x6330
jmp 0x861e
jmp 0x861b
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x8639
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6330
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x8655
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6330
leaq 0x60(%rsp), %rdi
callq 0x60b0
movq %rbx, %rdi
callq 0x6580
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x88(%rdi), %rdi
callq 0x81ae
movq 0x10(%rbx), %rax
cmpb $0x1, 0xe0(%rax)
jne 0x8dff
movq 0x13287(%rip), %r14     # 0x1bff0
leaq 0xb503(%rip), %rsi      # 0x14273
movl $0x6, %edx
movq %r14, %rdi
callq 0x63a0
callq 0x6480
movq %r14, %rdi
movl %eax, %esi
callq 0x6560
movq %rax, %r14
leaq 0xb4e4(%rip), %rsi      # 0x1427a
movl $0x6, %edx
movq %rax, %rdi
callq 0x63a0
movq 0x88(%rbx), %rax
movq 0x28(%rax), %rsi
movq 0x30(%rax), %rdx
movq %r14, %rdi
callq 0x63a0
movq %rax, %rbx
leaq 0xb479(%rip), %rsi      # 0x1423d
movl $0x8, %edx
movq %rax, %rdi
callq 0x63a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x61e0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0x8e54
movq %r14, %rdi
callq 0x6130
leaq 0x8(%rax), %rsi
leaq 0x60(%rbx), %rdi
callq 0x61c0
movl $0x1, 0x80(%rbx)
movl $0x8, %edi
callq 0x6190
movq %rbx, (%rax)
leaq 0x1267e(%rip), %rsi     # 0x1b4c0
movq %rax, %rdi
xorl %edx, %edx
callq 0x6550
movq %rax, %r14
callq 0x6500
movq %r14, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xa8(%rdi), %rdi
callq 0x8450
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0x9b4a
movq %r14, %rdi
callq 0x6130
leaq 0x8(%rax), %rsi
leaq 0x60(%rbx), %rdi
callq 0x61c0
movl $0x3, 0x80(%rbx)
movl $0x8, %edi
callq 0x6190
movq %rbx, (%rax)
leaq 0x11a68(%rip), %rsi     # 0x1b5a0
movq %rax, %rdi
xorl %edx, %edx
callq 0x6550
movq %rax, %r14
callq 0x6500
movq %r14, %rdi
callq 0x6580
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x11a6a(%rip), %rax     # 0x1b5d0
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
xorl %eax, %eax
movq %rax, 0x28(%rdi)
leaq 0x48(%rdi), %r14
movups %xmm0, 0x48(%rdi)
movq %rax, 0x58(%rdi)
leaq 0x70(%rdi), %r12
movq %r12, 0x60(%rdi)
movq %rax, 0x68(%rdi)
movb %al, 0x70(%rdi)
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movabsq $-0x3e7000003e8, %rdx   # imm = 0xFFFFFC18FFFFFC18
movq %rdx, 0x30(%rdi)
movq %rdx, 0x38(%rdi)
movl $0x0, 0x80(%rdi)
movb %al, 0x84(%rdi)
testq %rcx, %rcx
je 0x9bcd
movq %r14, %rdi
movq %rcx, %rsi
callq 0xa156
jmp 0x9bfb
movl %eax, 0x40(%rbx)
movl %eax, 0x4(%rsp)
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0x9bee
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x50(%rbx)
jmp 0x9bfb
leaq 0x4(%rsp), %rdx
movq %r14, %rdi
callq 0xa230
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x9c09
movq %rax, %r15
movq 0x60(%rbx), %rdi
cmpq %r12, %rdi
je 0x9c21
movq (%r12), %rsi
incq %rsi
callq 0x6330
leaq 0x18(%rbx), %r12
movq (%r14), %rdi
testq %rdi, %rdi
je 0x9c39
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x6330
movq (%r12), %rdi
testq %rdi, %rdi
je 0x9c4e
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x6330
movq %r15, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %rsi, (%rsp)
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x20(%rax)
movl %eax, %ebx
testb %al, %al
je 0x9cf4
movq 0x20(%r14), %rsi
cmpq 0x28(%r14), %rsi
je 0x9d05
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x20(%r14)
jmp 0x9d14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x9d14
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x9d14
addq $0x18, %r14
movq %rsp, %rdx
movq %r14, %rdi
callq 0xa36c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl %esi, %eax
movq %rdi, %rbx
movl %esi, 0x4(%rsp)
movl %esi, 0x40(%rdi)
movq 0x50(%rdi), %rsi
cmpq 0x58(%rdi), %rsi
je 0xa11c
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x50(%rbx)
jmp 0xa12a
leaq 0x48(%rbx), %rdi
leaq 0x4(%rsp), %rdx
callq 0xa4a8
movq 0x18(%rbx), %r14
movq 0x20(%rbx), %rbx
cmpq %rbx, %r14
je 0xa14d
movl 0x4(%rsp), %esi
movq (%r14), %rdi
movl %esi, 0x40(%rdi)
movq (%rdi), %rax
callq *0x30(%rax)
addq $0x8, %r14
jmp 0xa132
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6480
movl %eax, 0xe4(%r14)
movq (%r14), %rsi
movq %r14, %rdi
callq 0xc3bc
movq (%rbx), %rsi
testq %rsi, %rsi
je 0xa966
leaq 0x20(%rsp), %r13
addq $0x8, %rbx
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0xbc92
movq %r14, %rdi
movq %r15, %rsi
callq 0xc154
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xa95a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6330
movq (%rbx), %rsi
addq $0x8, %rbx
testq %rsi, %rsi
jne 0xa92d
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xa98e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0x8(%rdx), %rdx
testq %rdx, %rdx
je 0xb0e5
movq %rsi, %rbx
movq %rdi, %r14
movq (%r15), %rax
cmpb $0x2f, (%rax)
jne 0xafe0
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x61c0
jmp 0xb0a3
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x48(%r14), %rsi
movq 0x50(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x7456
leaq 0x960c(%rip), %rsi      # 0x14611
leaq 0x8(%rsp), %rdi
callq 0x65d0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x8(%rsp), %rdi
callq 0x6100
leaq 0x58(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xb047
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
jmp 0xb04e
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %r15
movq %rdx, 0x8(%r15)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x63f0
movq (%r15), %rdi
cmpq %rbp, %rdi
je 0xb08c
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x6330
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xb0a3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
addq $0x18, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbd82
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0xbdfe
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xb0d6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6330
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x93cf(%rip), %rdi      # 0x144bb
xorl %esi, %esi
xorl %eax, %eax
callq 0x64a0
jmp 0xb0f7
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xb118
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
jmp 0xb118
jmp 0xb115
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xb12f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
movq %rax, (%rdi)
leaq 0x92ba(%rip), %rsi      # 0x14451
leaq 0x92b8(%rip), %rdx      # 0x14456
callq 0x74e6
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x968f(%rip), %rdx      # 0x14842
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x74e6
addq $0x18, %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0xbe3c
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xb1e6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6330
movq (%r14), %rbp
movq 0x8(%r14), %r12
cmpq %r12, %rbp
je 0xb24e
movq %rsp, %r14
leaq 0x925b(%rip), %r15      # 0x14457
movq %r13, (%rsp)
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x7456
movq %r14, %rdi
movq %r15, %rsi
callq 0x65d0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x6100
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xb245
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6330
addq $0x20, %rbp
cmpq %r12, %rbp
jne 0xb1fc
movq %rbx, %rdi
callq 0x63e0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb273
jmp 0xb26c
movq %rax, %r14
jmp 0xb28c
jmp 0xb273
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xb28c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6330
movq (%rbx), %rdi
cmpq 0x20(%rsp), %rdi
je 0xb2a6
movq 0x20(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x6330
movq %r14, %rdi
callq 0x6580