LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/kztomita[P]http-dump/./buffer_view.h
// Function: buffer_view<unsigned char>::at_uint16(unsigned long) const
uint16_t at_uint16(std::size_t offset) const {
    std::size_t end = offset + 1;
    if (end < offset || end >= length_) {
      throw std::range_error("invalid offset");
    }
    uint16_t value = 0;
    memcpy(&value, buffer_ + offset, 2);
    return ntohs(value);
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $-0x1, %rsi
je 0x297e5
leaq 0x1(%rsi), %rax
cmpq 0x8(%rdi), %rax
jae 0x297e5
movq (%rdi), %rax
movzwl (%rax,%rsi), %eax
rolw $0x8, %ax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xb300
movq %rax, %rbx
leaq 0xae83(%rip), %rsi      # 0x3467c
movq %rax, %rdi
callq 0xbb70
movq 0x1e798(%rip), %rsi     # 0x47fa0
movq 0x1e731(%rip), %rdx     # 0x47f40
movq %rbx, %rdi
callq 0xbb60
movq %rax, %r14
movq %rbx, %rdi
callq 0xb4b0
movq %r14, %rdi
callq 0xbbb0
// File: /workspace/github_cpp_makefile_star2_O1/kztomita[P]http-dump/hpack_decoder.cc
// Function: hpack::hpack_decoder::decode[abi:cxx11](hpack::decoding_context&)
hpack_decoder::header_list_type hpack_decoder::decode(decoding_context& context) {
  decode_pos_ = 0;

  header_list_type headers;
  while (true) {
    auto result = decode_representation(context);
    // Dynamic Table Size Updateの場合はヘッダはないが
    // result.endはfalseなので処理を続ける。
    if (result.header) {
      headers.push_back(result.header.value());
    }
    if (result.end) {
      break;
    }
  }

  return headers;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x10(%rsi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x29974
cmpb $0x1, 0x40(%rsp)
jne 0x29924
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2a0a6
movb 0x48(%rsp), %bpl
cmpb $0x1, 0x40(%rsp)
jne 0x29938
movq %r12, %rdi
callq 0x2a1fa
testb %bpl, %bpl
je 0x29904
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
cmpb $0x1, 0x40(%rsp)
jne 0x29964
movq %rsp, %rdi
callq 0x2a1fa
jmp 0x29964
movq %rax, %r14
movq %rbx, %rdi
callq 0x19bbc
movq %r14, %rdi
callq 0xbbb0
// File: /workspace/github_cpp_makefile_star2_O1/kztomita[P]http-dump/hpack_decoder.cc
// Function: hpack::(anonymous namespace)::parse_integer_representation(buffer_view<unsigned char> const&, unsigned long, unsigned long)
std::pair<int, std::size_t>
parse_integer_representation(const buffer_view<unsigned char>& buffer, std::size_t offset, std::size_t n) {
  // 2 ^ n - 1
  int value_mask = (1 << n) - 1;

  int value = buffer.at(offset) & value_mask;
  if (value < value_mask) {
    return std::pair(value, 1);
  }

  // 全bitが立っている

  std::size_t next = offset + 1;

  int m = 0;
  while (true) {
    int octet = buffer.at(next);
    next++;

    value += (octet & 0x7f) << m;
    m += 7;

    if (!(octet & 0x80)) {
      break;
    }
  }

  return std::pair(value, next - offset);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rcx
movq %rsi, %rbx
movq %rdi, %r14
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
shll %cl, %r12d
notl %r12d
callq 0x296f6
movzbl %al, %ebp
andl %r12d, %ebp
movl $0x1, %r15d
cmpl %r12d, %ebp
jne 0x29cd0
xorl %r12d, %r12d
leaq (%rbx,%r15), %rsi
movq %r14, %rdi
callq 0x296f6
movl %eax, %ecx
andb $0x7f, %cl
movzbl %cl, %edx
movl %r12d, %ecx
shll %cl, %edx
addl %edx, %ebp
addl $0x7, %r12d
incq %r15
testb %al, %al
js 0x29caa
movl %ebp, %eax
movq %r15, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/kztomita[P]http-dump/hpack_decoder.cc
// Function: hpack::hpack_decoder::fetch_header[abi:cxx11](hpack::decoding_context const&, unsigned long)
header_type hpack_decoder::fetch_header(const decoding_context& context, std::size_t index) {
  if (index) {
    // parse value string literal

    auto h = hpack_table_at(*context.dynamic_table, index);
    if (!h) {
      throw std::runtime_error("header not found in tables.");
    }

    // Value String
    std::string value = fetch_string();

    return header_type(h.value().first, value);
  } else {
    // parse name string literal and value string literal

    // Name String
    std::string name = fetch_string();

    // Value String
    std::string value = fetch_string();

    return header_type(name, value);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testq %rcx, %rcx
je 0x29f40
movq (%rdx), %rsi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %rcx, %rdx
callq 0x2a72e
cmpb $0x0, 0x40(%r15)
je 0x29faf
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x29cde
cmpb $0x0, 0x68(%rsp)
je 0x29fe1
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x2a0d2
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x29f2d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb600
cmpb $0x1, 0x68(%rsp)
jne 0x29fa2
leaq 0x28(%rsp), %rdi
callq 0x2a1fa
jmp 0x29fa2
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x29cde
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x29cde
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x2a0d2
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x29f87
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb600
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x29fa2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb600
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0xb300
movq %rax, %r14
leaq 0xa8c7(%rip), %rsi      # 0x3488a
movq %rax, %rdi
callq 0xb270
movq 0x1e01e(%rip), %rsi     # 0x47ff0
movq 0x1df77(%rip), %rdx     # 0x47f50
movq %r14, %rdi
callq 0xbb60
callq 0x24915
jmp 0x2a035
movq %rax, %rbx
movq %r14, %rdi
callq 0xb4b0
jmp 0x2a058
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a018
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb600
jmp 0x2a018
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a069
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb600
jmp 0x2a069
movq %rax, %rbx
jmp 0x2a058
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a058
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb600
cmpb $0x1, 0x68(%rsp)
jne 0x2a069
leaq 0x28(%rsp), %rdi
callq 0x2a1fa
movq %rbx, %rdi
callq 0xbbb0
nop
// File: /workspace/github_cpp_makefile_star2_O1/kztomita[P]http-dump/./buffer_view.h
// Function: buffer_view<unsigned char>::subview(unsigned long, unsigned long) const
buffer_view subview(std::size_t offset, std::size_t length) const {
    std::size_t end = offset + length;
    if (end < offset || end > length_) {
      throw std::range_error("invalid offset or length");
    }
    return buffer_view(buffer_ + offset, length);
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rax
addq %rsi, %rax
jb 0x2a156
cmpq 0x8(%rdi), %rax
ja 0x2a156
addq (%rdi), %rsi
movq %rsi, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xb300
movq %rax, %rbx
leaq 0xa754(%rip), %rsi      # 0x348be
movq %rax, %rdi
callq 0xbb70
movq 0x1de27(%rip), %rsi     # 0x47fa0
movq 0x1ddc0(%rip), %rdx     # 0x47f40
movq %rbx, %rdi
callq 0xbb60
movq %rax, %r14
movq %rbx, %rdi
callq 0xb4b0
movq %r14, %rdi
callq 0xbbb0
nop
// File: /workspace/github_cpp_makefile_star2_O1/kztomita[P]http-dump/hpack_table.cc
// Function: hpack::hpack_dynamic_table::dump() const
void hpack_dynamic_table::dump() const {
  std::cout << "Table Size: " << table_size() << " (Maximum:" << max_size_ << ")" << std::endl;

  auto calculated_size = calc_table_size();
  if (table_size() != calculated_size) {
    std::cout << "ERROR: Calculated Table Size mismatched (" << calculated_size << ")" << std::endl;
  }

  int i = 1;
  for (auto e = entries_.rbegin(); e != entries_.rend(); ++e) {
    std::cout << "[" << i << "] " << e->first << " " << e->second << std::endl;
    i++;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1da43(%rip), %r14     # 0x47f88
leaq 0xa63f(%rip), %rsi      # 0x34b8b
movl $0xc, %edx
movq %r14, %rdi
callq 0xb730
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0xb440
movq %rax, %r14
leaq 0xa629(%rip), %rsi      # 0x34b98
movl $0xa, %edx
movq %rax, %rdi
callq 0xb730
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0xb440
movq %rax, %r14
leaq 0x7b8d(%rip), %rsi      # 0x3211f
movl $0x1, %edx
movq %rax, %rdi
callq 0xb730
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xb5b0
movsbl %al, %esi
movq %r14, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb450
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
xorl %r14d, %r14d
cmpq %rcx, %rax
je 0x2a5ea
addq 0x8(%rax), %r14
movq 0x28(%rax), %rdx
addq %rdx, %r14
addq $0x20, %r14
addq $0x40, %rax
jmp 0x2a5d0
cmpq %r14, 0x20(%rbx)
je 0x2a654
movq 0x1d991(%rip), %r15     # 0x47f88
leaq 0xa5a5(%rip), %rsi      # 0x34ba3
movl $0x29, %edx
movq %r15, %rdi
callq 0xb730
movq %r15, %rdi
movq %r14, %rsi
callq 0xb440
movq %rax, %r14
leaq 0x7aff(%rip), %rsi      # 0x3211f
movl $0x1, %edx
movq %rax, %rdi
callq 0xb730
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xb5b0
movsbl %al, %esi
movq %r14, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb450
movq 0x8(%rbx), %r12
cmpq (%rbx), %r12
je 0x2a71a
movl $0x1, %ebp
movq 0x1d91b(%rip), %r14     # 0x47f88
movl $0x1, %edx
movq %r14, %rdi
leaq 0xa551(%rip), %rsi      # 0x34bcd
callq 0xb730
movq %r14, %rdi
movl %ebp, %esi
callq 0xbb80
movq %rax, %r15
movl $0x2, %edx
movq %rax, %rdi
leaq 0xa532(%rip), %rsi      # 0x34bcf
callq 0xb730
leaq -0x40(%r12), %r13
movq -0x40(%r12), %rsi
movq -0x38(%r12), %rdx
movq %r15, %rdi
callq 0xb730
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
leaq 0xa0c7(%rip), %rsi      # 0x34792
callq 0xb730
movq -0x20(%r12), %rsi
movq -0x18(%r12), %rdx
movq %r15, %rdi
callq 0xb730
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0xb5b0
movsbl %al, %esi
movq %r15, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb450
incl %ebp
movq %r13, %r12
cmpq (%rbx), %r13
jne 0x2a66d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/kztomita[P]http-dump/hpack_table.cc
// Function: hpack::hpack_table_at[abi:cxx11](hpack::hpack_dynamic_table const&, unsigned long)
std::optional<hpack::header_type>
hpack_table_at(const hpack_dynamic_table& dynamic_table, std::size_t index) {
  if (index == 0) {
    return std::nullopt;
  }
  if (index >= 1 && index <= hpack_static_table.size()) {
    return std::make_optional(hpack_static_table_at(index));
  }
  if (index >= hpack_static_table.size() + 1 && index <= hpack_static_table.size() + dynamic_table.size()) {
    return std::make_optional(dynamic_table.at(index - hpack_static_table.size() - 1));
  }
  return std::nullopt;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
testq %rdx, %rdx
je 0x2a774
movq 0x1e584(%rip), %rax     # 0x48cc8
subq 0x1e575(%rip), %rax     # 0x48cc0
sarq $0x6, %rax
cmpq %rdx, %rax
jae 0x2a77d
leaq 0x1(%rax), %rcx
cmpq %rdx, %rcx
ja 0x2a774
movq 0x8(%rsi), %rcx
subq (%rsi), %rcx
sarq $0x6, %rcx
addq %rax, %rcx
cmpq %rdx, %rcx
jae 0x2a83a
movb $0x0, 0x40(%rbx)
jmp 0x2a82f
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x2a348
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%r14), %rdx
leaq 0x18(%rsp), %rax
cmpq %rax, %rdx
je 0x2a7af
movq %rdx, (%rbx)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rbx)
jmp 0x2a7b5
movups (%rax), %xmm0
movups %xmm0, (%rcx)
leaq 0x38(%rsp), %rcx
movq -0x28(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movq %rax, -0x30(%rcx)
movq $0x0, -0x28(%rcx)
movb $0x0, -0x20(%rcx)
leaq 0x30(%rbx), %rdx
movq %rdx, 0x20(%rbx)
movq -0x10(%rcx), %rsi
cmpq %rcx, %rsi
je 0x2a7f2
movq %rsi, 0x20(%rbx)
movq 0x38(%rsp), %rdx
movq %rdx, 0x30(%rbx)
jmp 0x2a7f8
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x30(%rsp), %rdx
movq %rdx, 0x28(%rbx)
movq %rcx, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movb $0x0, 0x38(%rsp)
movb $0x1, 0x40(%rbx)
movq 0x8(%rsp), %rdi
cmpq %rax, %rdi
je 0x2a82f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb600
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
notq %rax
addq %rdx, %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rdx
callq 0x2a44e
jmp 0x2a78d
nop
// File: /workspace/github_cpp_makefile_star2_O1/kztomita[P]http-dump/hpack_huffman.cc
// Function: hpack::decode_huffman(unsigned char const*, unsigned long)
std::vector<unsigned char> decode_huffman(const unsigned char* start, std::size_t length) {

  unsigned int offset = 0;
  unsigned int offset_end = length * 8;

  std::vector<unsigned char> decoded;

  auto root = treep->get_root();
  auto node = root;

  while (offset < offset_end) {
    // fetch a bit
    unsigned int bit = (start[offset >> 3] & (0x80 >> (offset & 7))) ? 1 : 0;

    if (bit) {
      if (!node->right) {
        throw std::logic_error("decode error.");
      }
      node = node->right.get();
    } else {
      if (!node->left) {
        throw std::logic_error("decode error.");
      }
      node = node->left.get();
    }
    if (node->value != -1) {
      // found
      if (node->value == 256) {
        break;
      }
      decoded.push_back(node->value);
      node = root;
    }

    offset++;
  }

  return decoded;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
shll $0x3, %r14d
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x1d7bd(%rip), %rax     # 0x48ce0
movq (%rax), %r13
xorl %ebp, %ebp
leaq 0x7(%rsp), %r12
movq %r13, %rax
cmpl %r14d, %ebp
jae 0x2b58b
movl %ebp, %ecx
shrl $0x3, %ecx
movzbl (%r15,%rcx), %edx
movl %ebp, %ecx
andb $0x7, %cl
shll %cl, %edx
testb %dl, %dl
jns 0x2b555
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x2b55d
jmp 0x2b59d
movq (%rax), %rax
testq %rax, %rax
je 0x2b5bb
movl 0x10(%rax), %ecx
cmpl $-0x1, %ecx
je 0x2b583
cmpl $0x100, %ecx            # imm = 0x100
jne 0x2b571
xorl %ecx, %ecx
jmp 0x2b587
movb %cl, 0x7(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x282f2
movq %r13, %rax
incl %ebp
movb $0x1, %cl
testb %cl, %cl
jne 0x2b530
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xb300
movq %rax, %r14
leaq 0x9621(%rip), %rsi      # 0x34bd2
movq %rax, %rdi
callq 0xb990
jmp 0x2b5d7
movl $0x10, %edi
callq 0xb300
movq %rax, %r14
leaq 0x9603(%rip), %rsi      # 0x34bd2
movq %rax, %rdi
callq 0xb990
movq 0x1c9da(%rip), %rsi     # 0x47fb8
movq 0x1c993(%rip), %rdx     # 0x47f78
movq %r14, %rdi
callq 0xbb60
jmp 0x2b5ef
movq %rax, %r15
movq %r14, %rdi
callq 0xb4b0
jmp 0x2b601
jmp 0x2b5fe
movq %rax, %r15
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2b615
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0xb600
movq %r15, %rdi
callq 0xbbb0
nop
// File: /workspace/github_cpp_makefile_star2_O1/kztomita[P]http-dump/sync_stream_wrapper.cc
// Function: (anonymous namespace)::ssl_keylog_callback(ssl_st const*, char const*)
void ssl_keylog_callback(const SSL *ssl, const char *line) {
  std::ofstream fs(g_keylog_file, std::ios_base::out | std::ios_base::app);
  if (!fs) {
    std::cerr << "Can't open " << g_keylog_file << std::endl;
  }

  fs << line << std::endl;

  fs.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %r14
movq 0x1d235(%rip), %rsi     # 0x48bc0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl $0x11, %edx
callq 0xb6a0
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
je 0x2ba35
movq 0x1c632(%rip), %r15     # 0x47fe8
leaq 0x9ae6(%rip), %rsi      # 0x354a3
movl $0xb, %edx
movq %r15, %rdi
callq 0xb730
movq 0x1d1ef(%rip), %r12     # 0x48bc0
testq %r12, %r12
je 0x2b9f2
movq %r12, %rdi
callq 0xb2c0
movq 0x1c603(%rip), %rdi     # 0x47fe8
movq %r12, %rsi
movq %rax, %rdx
callq 0xb730
jmp 0x2ba0a
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0xbb50
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0xb5b0
movsbl %al, %esi
movq 0x1c5c0(%rip), %rdi     # 0x47fe8
callq 0xb050
movq %rax, %rdi
callq 0xb450
testq %r14, %r14
je 0x2ba54
movq %r14, %rdi
callq 0xb2c0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xb730
jmp 0x2ba70
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %rdi
addq $0x8, %rdi
movl 0x20(%rdi), %esi
orl $0x1, %esi
callq 0xbb50
movq 0x8(%rsp), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0xb5b0
movsbl %al, %esi
leaq 0x8(%rsp), %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb450
leaq 0x8(%rsp), %rdi
callq 0xb960
movq 0x1c48c(%rip), %rax     # 0x47f38
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0xb520
leaq 0x100(%rsp), %rdi
callq 0xb1f0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb9e0
movq %rbx, %rdi
callq 0xbbb0
nop
// File: /workspace/github_cpp_makefile_star2_O1/kztomita[P]http-dump/sync_stream_wrapper.cc
// Function: ssl_stream::connect(boost::asio::ip::address const&, unsigned short)
void ssl_stream::connect(const boost::asio::ip::address& ip, uint16_t port) {
  stream_->lowest_layer().connect(asio::ip::tcp::endpoint(ip, port));

  if (verify_cert_) {
    // for SNI
    SSL_set_tlsext_host_name(stream_->native_handle(), host_.c_str());

    stream_->set_verify_mode(asio::ssl::verify_peer);
    stream_->set_verify_callback(asio::ssl::rfc2818_verification(host_));
  }

  stream_->handshake(asio::ssl::stream_base::client);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x58(%rdi), %r14
leaq 0x2c(%rsp), %r15
movq %r15, %rdi
callq 0x2bd9e
movq %r14, %rdi
movq %r15, %rsi
callq 0x2bc5a
cmpb $0x1, 0x30(%rbx)
jne 0x2bbba
movq 0x38(%rbx), %rcx
movq 0x58(%rbx), %rax
movq 0x50(%rax), %rdi
movl $0x37, %esi
xorl %edx, %edx
callq 0xb280
movq 0x58(%rbx), %rax
movq 0x50(%rax), %r14
movq %r14, %rdi
callq 0xb220
movq %r14, %rdi
movl $0x1, %esi
movq %rax, %rdx
callq 0xb460
movq 0x58(%rbx), %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x38(%rbx), %rsi
movq 0x40(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xe53c
movq %r14, %rdi
movq %r15, %rsi
callq 0x2c3ca
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2bbba
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb600
movq 0x58(%rbx), %rdi
xorl %esi, %esi
callq 0x2c4d0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2bbeb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb600
movq %rbx, %rdi
callq 0xbbb0
nop
// File: /workspace/github_cpp_makefile_star2_O1/kztomita[P]http-dump/dump.cc
// Function: dump(void const*, unsigned long, unsigned long)
void dump(const void* p, std::size_t size, std::size_t max = 0) {
  const char* p2 = reinterpret_cast<const char*>(p);

  std::size_t last_offset = size;
  bool snip = false;
  if (max && size > max) {
    last_offset = max;
    snip = true;
  }

  for (std::size_t offset = 0 ; offset < last_offset ; offset += 16) {
    if (offset + 16 <= last_offset) {
      out_line(p2 + offset, p2 + offset + 16, false);
    } else {
      out_line(p2 + offset, p2 + last_offset, snip);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
testq %rdx, %rdx
setne %cl
cmpq %rdx, %rsi
seta %al
andb %cl, %al
cmovneq %rdx, %rbx
testq %rbx, %rbx
je 0x3105d
movq %rdi, %r14
leaq (%rdi,%rbx), %r15
xorl %r12d, %r12d
movzbl %al, %ebp
addq $0x10, %r12
cmpq %rbx, %r12
jbe 0x31046
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
jmp 0x3104f
leaq 0x10(%r14), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x31066
addq $0x10, %r14
cmpq %rbx, %r12
jb 0x31033
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::yyensure_buffer_stack()
void yyFlexLexer::yyensure_buffer_stack(void)
{
	yy_size_t num_to_alloc;
    
	if (!(yy_buffer_stack)) {

		/* First allocation is just for 2 elements, since we don't know if this
		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
		 * immediate realloc on the next call.
         */
      num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
		(yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
								(num_to_alloc * sizeof(struct yy_buffer_state*)
								);
		if ( ! (yy_buffer_stack) )
			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );

		memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));

		(yy_buffer_stack_max) = num_to_alloc;
		(yy_buffer_stack_top) = 0;
		return;
	}

	if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){

		/* Increase the buffer to prepare for a possible push. */
		yy_size_t grow_size = 8 /* arbitrary grow size */;

		num_to_alloc = (yy_buffer_stack_max) + grow_size;
		(yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
								((yy_buffer_stack),
								num_to_alloc * sizeof(struct yy_buffer_state*)
								);
		if ( ! (yy_buffer_stack) )
			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );

		/* zero only the new slots.*/
		memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
		(yy_buffer_stack_max) = num_to_alloc;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x288(%rdi), %rdi
testq %rdi, %rdi
je 0x3e98
movq 0x280(%rbx), %r14
leaq -0x1(%r14), %rax
cmpq %rax, 0x278(%rbx)
jb 0x3edc
leaq 0x40(,%r14,8), %rsi
addq $0x8, %r14
callq 0x3350
movq %rax, 0x288(%rbx)
testq %rax, %rax
jne 0x3e6b
movq (%rbx), %rax
leaq 0x89ae(%rip), %rsi      # 0xc813
movq %rbx, %rdi
callq *0x70(%rax)
movq 0x280(%rbx), %rax
movq 0x288(%rbx), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rcx,%rax,8)
movups %xmm0, 0x20(%rcx,%rax,8)
movups %xmm0, 0x10(%rcx,%rax,8)
movups %xmm0, (%rcx,%rax,8)
movq %r14, 0x280(%rbx)
jmp 0x3edc
movl $0x8, %edi
callq 0x32d0
movq %rax, 0x288(%rbx)
testq %rax, %rax
jne 0x3ebe
movq (%rbx), %rax
leaq 0x895b(%rip), %rsi      # 0xc813
movq %rbx, %rdi
callq *0x70(%rax)
movq 0x288(%rbx), %rax
xorl %ecx, %ecx
movq %rcx, (%rax)
movq $0x1, 0x280(%rbx)
movq %rcx, 0x278(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::yy_load_buffer_state()
void yyFlexLexer::yy_load_buffer_state()
{
    	(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
	(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
	yyin.rdbuf(YY_CURRENT_BUFFER_LVALUE->yy_input_file);
	(yy_hold_char) = *(yy_c_buf_p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x288(%rdi), %rax
movq 0x278(%rdi), %rcx
movq (%rax,%rcx,8), %rdx
movl 0x1c(%rdx), %esi
movl %esi, 0x25c(%rdi)
movq 0x10(%rdx), %rdx
movq %rdx, 0x260(%rdi)
movq %rdx, 0x8(%rdi)
addq $0x30, %rdi
movq 0x30(%rbx), %rdx
addq -0x18(%rdx), %rdi
movq (%rax,%rcx,8), %rax
movq (%rax), %rsi
callq 0x33c0
movq 0x260(%rbx), %rax
movb (%rax), %al
movb %al, 0x258(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::yy_try_NUL_trans(int)
yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )
{
	int yy_is_jam;
    	char *yy_cp = (yy_c_buf_p);

	YY_CHAR yy_c = 1;
	if ( yy_accept[yy_current_state] )
		{
		(yy_last_accepting_state) = yy_current_state;
		(yy_last_accepting_cpos) = yy_cp;
		}
	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		{
		yy_current_state = (int) yy_def[yy_current_state];
		if ( yy_current_state >= 100 )
			yy_c = yy_meta[yy_c];
		}
	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	yy_is_jam = (yy_current_state == 99);

		return yy_is_jam ? 0 : yy_current_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %esi, %rax
leaq -0x63(%rax), %rcx
cmpq $-0x60, %rcx
jb 0x4035
movq 0x260(%rdi), %rcx
movl %esi, 0x290(%rdi)
movq %rcx, 0x298(%rdi)
leaq 0x8384(%rip), %rdx      # 0xc3c0
movswq (%rdx,%rax,2), %rcx
leaq 0x8248(%rip), %rdi      # 0xc290
movswl 0x2(%rdi,%rcx,2), %r8d
cmpl %esi, %r8d
je 0x406b
leaq 0x8436(%rip), %rsi      # 0xc490
movswq (%rsi,%rax,2), %rax
movswq (%rdx,%rax,2), %rcx
cmpw 0x2(%rdi,%rcx,2), %ax
jne 0x405a
incq %rcx
leaq 0x851b(%rip), %rax      # 0xc590
movzwl (%rax,%rcx,2), %eax
xorl %ecx, %ecx
cmpw $0x63, %ax
cmovnel %eax, %ecx
movswl %cx, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::~yyFlexLexer()
yyFlexLexer::~yyFlexLexer()
{
	delete [] yy_state_buf;
	yyfree( yy_start_stack  );
	yy_delete_buffer( YY_CURRENT_BUFFER );
	yyfree( yy_buffer_stack  );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xd308(%rip), %rax      # 0x118c8
movq %rax, (%rdi)
movq 0x2a0(%rdi), %rdi
testq %rdi, %rdi
je 0x45d4
callq 0x32b0
movq 0x28(%rbx), %rdi
callq 0x3280
movq 0x288(%rbx), %rax
testq %rax, %rax
je 0x45f6
movq 0x278(%rbx), %rcx
movq (%rax,%rcx,8), %rsi
jmp 0x45f8
xorl %esi, %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movq 0x288(%rbx), %rdi
callq 0x3280
leaq 0x150(%rbx), %rdi
callq 0x30d0
movq 0xd9a8(%rip), %rax      # 0x11fc8
movq (%rax), %rcx
movq 0x8(%rax), %rax
movq %rcx, 0x30(%rbx)
movq -0x18(%rcx), %rcx
movq %rax, 0x30(%rbx,%rcx)
movq $0x0, 0x38(%rbx)
addq $0x40, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x30d0
movq %rax, %rdi
callq 0x4ede
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::switch_streams(std::istream&, std::ostream&)
void yyFlexLexer::switch_streams( std::istream& new_in, std::ostream& new_out )
{
	// was if( new_in )
	yy_delete_buffer( YY_CURRENT_BUFFER );
	yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE  ) );

	// was if( new_out )
	yyout.rdbuf(new_out.rdbuf());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x288(%rdi), %rax
testq %rax, %rax
je 0x46ae
movq 0x278(%r14), %rcx
movq (%rax,%rcx,8), %rsi
jmp 0x46b0
xorl %esi, %esi
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
movl $0x4000, %edx           # imm = 0x4000
callq *0x20(%rax)
movq (%r14), %rcx
movq %r14, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
movq 0x148(%r14), %rax
addq $0x148, %r14            # imm = 0x148
addq -0x18(%rax), %r14
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq 0xe8(%rbx,%rax), %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::LexerInput(char*, int)
int yyFlexLexer::LexerInput( char* buf, int max_size )
#endif
{
	if ( yyin.eof() || yyin.fail() )
		return 0;

#ifdef YY_INTERACTIVE
	yyin.get( buf[0] );

	if ( yyin.eof() )
		return 0;

	if ( yyin.bad() )
		return -1;

	return 1;

#else
	(void) yyin.read( buf, max_size );

	if ( yyin.bad() )
		return -1;
	else
		return yyin.gcount();
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x30(%rdi), %rax
movq -0x18(%rax), %rax
xorl %ebx, %ebx
testb $0x7, 0x50(%rdi,%rax)
jne 0x4773
movq %rdi, %r14
addq $0x30, %r14
movq %r14, %rdi
callq 0x32e0
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x20(%r14,%rax), %eax
testb $0x2, %al
jne 0x4773
andl $0x1, %eax
negl %eax
orl $0x1, %eax
movl %eax, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::yyunput(int, char*)
void yyFlexLexer::yyunput( int c, char* yy_bp)
{
	char *yy_cp;
    
    yy_cp = (yy_c_buf_p);

	/* undo effects of setting up yytext */
	*yy_cp = (yy_hold_char);

	if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
		{ /* need to shift things up to make room */
		/* +2 for EOB chars. */
		int number_to_move = (yy_n_chars) + 2;
		char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
					YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
		char *source =
				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];

		while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
			*--dest = *--source;

		yy_cp += (int) (dest - source);
		yy_bp += (int) (dest - source);
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
			(yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;

		if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
			YY_FATAL_ERROR( "flex scanner push-back overflow" );
		}

	*--yy_cp = (char) c;

    if ( c == '\n' ){
        --yylineno;
    }

	(yytext_ptr) = yy_bp;
	(yy_hold_char) = *yy_cp;
	(yy_c_buf_p) = yy_cp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movq 0x260(%rdi), %r12
movb 0x258(%rdi), %al
movb %al, (%r12)
movq 0x278(%rdi), %rax
movq 0x288(%rdi), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rcx
leaq 0x2(%rcx), %rdx
cmpq %rdx, %r12
jae 0x484d
movslq 0x25c(%rbx), %rdx
movslq 0x18(%rax), %rax
addq %rcx, %rax
addq $0x2, %rax
addq %rdx, %rcx
addq $0x2, %rcx
movq 0x278(%rbx), %rdx
movq 0x288(%rbx), %rsi
movq (%rsi,%rdx,8), %rsi
movq 0x8(%rsi), %rdx
cmpq %rdx, %rcx
jbe 0x481e
movb -0x1(%rcx), %dl
decq %rcx
movb %dl, -0x1(%rax)
decq %rax
jmp 0x47f5
subl %ecx, %eax
cltq
addq %rax, %r12
addq %rax, %r14
movl 0x18(%rsi), %eax
movl %eax, 0x25c(%rbx)
movl %eax, 0x1c(%rsi)
addq $0x2, %rdx
cmpq %rdx, %r12
jae 0x484d
movq (%rbx), %rax
leaq 0x7f80(%rip), %rsi      # 0xc7c7
movq %rbx, %rdi
callq *0x70(%rax)
movb %r15b, -0x1(%r12)
decq %r12
cmpl $0xa, %r15d
jne 0x485e
decl 0x14(%rbx)
movq %r14, 0x8(%rbx)
movb (%r12), %al
movb %al, 0x258(%rbx)
movq %r12, 0x260(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::yyinput()
int yyFlexLexer::yyinput()
{
	int c;
    
	*(yy_c_buf_p) = (yy_hold_char);

	if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
		{
		/* yy_c_buf_p now points to the character we want to return.
		 * If this occurs *before* the EOB characters, then it's a
		 * valid NUL; if not, then we've hit the end of the buffer.
		 */
		if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
			/* This was really a NUL. */
			*(yy_c_buf_p) = '\0';

		else
			{ /* need more input */
			int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
			++(yy_c_buf_p);

			switch ( yy_get_next_buffer(  ) )
				{
				case EOB_ACT_LAST_MATCH:
					/* This happens because yy_g_n_b()
					 * sees that we've accumulated a
					 * token and flags that we need to
					 * try matching the token before
					 * proceeding.  But for input(),
					 * there's no matching to consider.
					 * So convert the EOB_ACT_LAST_MATCH
					 * to EOB_ACT_END_OF_FILE.
					 */

					/* Reset buffer status. */
					yyrestart( yyin );

					/*FALLTHROUGH*/

				case EOB_ACT_END_OF_FILE:
					{
					if ( yywrap(  ) )
						return 0;

					if ( ! (yy_did_buffer_switch_on_eof) )
						YY_NEW_FILE;
#ifdef __cplusplus
					return yyinput();
#else
					return input();
#endif
					}

				case EOB_ACT_CONTINUE_SCAN:
					(yy_c_buf_p) = (yytext_ptr) + offset;
					break;
				}
			}
		}

	c = *(unsigned char *) (yy_c_buf_p);	/* cast for 8-bit char's */
	*(yy_c_buf_p) = '\0';	/* preserve yytext */
	(yy_hold_char) = *++(yy_c_buf_p);

	if ( c == '\n' )
		
    yylineno++;
;

	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x258(%rdi), %al
movq 0x260(%rdi), %rcx
movb %al, (%rcx)
movq 0x260(%rdi), %r14
cmpb $0x0, (%r14)
jne 0x494d
movq 0x278(%rbx), %rax
movq 0x288(%rbx), %rcx
movq (%rcx,%rax,8), %rax
movslq 0x25c(%rbx), %rcx
addq 0x8(%rax), %rcx
cmpq %rcx, %r14
jae 0x48d1
movb $0x0, (%r14)
jmp 0x494d
movq 0x8(%rbx), %r15
leaq 0x1(%r14), %rax
movq %rax, 0x260(%rbx)
movq %rbx, %rdi
callq 0x4088
testl %eax, %eax
je 0x4936
cmpl $0x1, %eax
je 0x48fe
leaq 0x30(%rbx), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x38(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x58(%rax)
movl %eax, %ecx
xorl %eax, %eax
movl $0x0, %edx
testl %ecx, %ecx
jne 0x4949
cmpl $0x0, 0x270(%rbx)
jne 0x492a
leaq 0x30(%rbx), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x38(%rax)
movq %rbx, %rdi
callq 0x487c
xorl %edx, %edx
jmp 0x4949
subl %r15d, %r14d
movslq %r14d, %rax
addq 0x8(%rbx), %rax
movq %rax, 0x260(%rbx)
movb $0x1, %dl
testb %dl, %dl
je 0x497d
movq 0x260(%rbx), %rcx
movzbl (%rcx), %eax
movb $0x0, (%rcx)
movq 0x260(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x260(%rbx)
movb 0x1(%rcx), %cl
movb %cl, 0x258(%rbx)
cmpl $0xa, %eax
jne 0x497d
incl 0x14(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::yyrestart(std::istream&)
void yyFlexLexer::yyrestart( std::istream& input_file )
{
    
	if ( ! YY_CURRENT_BUFFER ){
        yyensure_buffer_stack ();
		YY_CURRENT_BUFFER_LVALUE =
            yy_create_buffer( yyin, YY_BUF_SIZE );
	}

	yy_init_buffer( YY_CURRENT_BUFFER, input_file );
	yy_load_buffer_state(  );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x288(%rdi), %rax
testq %rax, %rax
je 0x49af
movq 0x278(%rbx), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x49db
movq %rbx, %rdi
callq 0x3e10
leaq 0x30(%rbx), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
movl $0x4000, %edx           # imm = 0x4000
callq *0x20(%rax)
movq 0x278(%rbx), %rcx
movq 0x288(%rbx), %rdx
movq %rax, (%rdx,%rcx,8)
movq 0x288(%rbx), %rax
testq %rax, %rax
je 0x49f4
movq 0x278(%rbx), %rcx
movq (%rax,%rcx,8), %rsi
jmp 0x49f6
xorl %esi, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4a0e
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3ee2
nop
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::yy_init_buffer(yy_buffer_state*, std::istream&)
void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, std::istream& file )

{
	int oerrno = errno;
    
	yy_flush_buffer( b );

	b->yy_input_file = file.rdbuf();
	b->yy_fill_buffer = 1;

    /* If b is the current buffer, then yy_init_buffer was _probably_
     * called from yyrestart() or through yy_get_next_buffer.
     * In that case, we don't want to reset the lineno or column.
     */
    if (b != YY_CURRENT_BUFFER){
        b->yy_bs_lineno = 1;
        b->yy_bs_column = 0;
    }

	b->yy_is_interactive = 0;
	errno = oerrno;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
callq 0x3050
movq %rax, %r14
movl (%rax), %r13d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4c4e
movq (%r12), %rax
movq -0x18(%rax), %rax
movq 0xe8(%r12,%rax), %rax
movq %rax, (%rbx)
movl $0x1, 0x34(%rbx)
movq 0x288(%r15), %rax
testq %rax, %rax
je 0x4a6e
movq 0x278(%r15), %rcx
movq (%rax,%rcx,8), %rax
jmp 0x4a70
xorl %eax, %eax
cmpq %rbx, %rax
je 0x4a7d
movq $0x1, 0x2c(%rbx)
movl $0x0, 0x24(%rbx)
movl %r13d, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::yy_create_buffer(std::istream&, int)
YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( std::istream& file, int size )
{
	YY_BUFFER_STATE b;
    
	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state )  );
	if ( ! b )
		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

	b->yy_buf_size = size;

	/* yy_ch_buf has to be 2 characters longer than the size given because
	 * we need to put in 2 end-of-buffer characters.
	 */
	b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2)  );
	if ( ! b->yy_ch_buf )
		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

	b->yy_is_our_buffer = 1;

	yy_init_buffer( b, file );

	return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r15
movl $0x40, %edi
callq 0x32d0
movq %rax, %r14
testq %rax, %rax
jne 0x4b8e
movq (%r15), %rax
leaq 0x7c5f(%rip), %rsi      # 0xc7e7
movq %r15, %rdi
callq *0x70(%rax)
movl %r12d, 0x18(%r14)
addl $0x2, %r12d
movslq %r12d, %rdi
callq 0x32d0
movq %rax, 0x8(%r14)
testq %rax, %rax
jne 0x4bb7
movq (%r15), %rax
leaq 0x7c36(%rip), %rsi      # 0xc7e7
movq %r15, %rdi
callq *0x70(%rax)
movl $0x1, 0x20(%r14)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4a0e
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::yy_delete_buffer(yy_buffer_state*)
void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b )
{
    
	if ( ! b )
		return;

	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;

	if ( b->yy_is_our_buffer )
		yyfree( (void *) b->yy_ch_buf  );

	yyfree( (void *) b  );
}

// Assembly:
testq %rsi, %rsi
je 0x4c19
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x288(%rdi), %rax
testq %rax, %rax
je 0x4c1a
movq 0x278(%rdi), %rcx
movq (%rax,%rcx,8), %rcx
jmp 0x4c1c
retq
xorl %ecx, %ecx
cmpq %rbx, %rcx
jne 0x4c30
movq 0x278(%rdi), %rcx
movq $0x0, (%rax,%rcx,8)
cmpl $0x0, 0x20(%rbx)
je 0x4c3f
movq 0x8(%rbx), %rdi
callq 0x3280
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3280
nop
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::yy_push_state(int)
void yyFlexLexer::yy_push_state( int _new_state )
{
    	if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) )
		{
		yy_size_t new_size;

		(yy_start_stack_depth) += YY_START_STACK_INCR;
		new_size = (yy_size_t) (yy_start_stack_depth) * sizeof( int );

		if ( ! (yy_start_stack) )
			(yy_start_stack) = (int *) yyalloc( new_size  );

		else
			(yy_start_stack) = (int *) yyrealloc(
					(void *) (yy_start_stack), new_size  );

		if ( ! (yy_start_stack) )
			YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
		}

	(yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;

	BEGIN(_new_state);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movslq 0x20(%rdi), %rax
cmpl %eax, 0x1c(%rdi)
jl 0x4e30
leaq 0x19(%rax), %rcx
movl %ecx, 0x20(%rbx)
leaq 0x64(,%rax,4), %rsi
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x4e0f
callq 0x3350
jmp 0x4e17
movq %rsi, %rdi
callq 0x32d0
movq %rax, 0x28(%rbx)
testq %rax, %rax
jne 0x4e30
movq (%rbx), %rax
leaq 0x7a1a(%rip), %rsi      # 0xc844
movq %rbx, %rdi
callq *0x70(%rax)
movl 0x26c(%rbx), %eax
movl %eax, %ecx
decl %ecx
shrl $0x1f, %ecx
addl %ecx, %eax
decl %eax
sarl %eax
movq 0x28(%rbx), %rcx
movslq 0x1c(%rbx), %rdx
leal 0x1(%rdx), %esi
movl %esi, 0x1c(%rbx)
movl %eax, (%rcx,%rdx,4)
leal 0x1(%r14,%r14), %eax
movl %eax, 0x26c(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/while.cc
// Function: yylex(yy::parser::value_type*, yy::location*)
int yylex(yy::parser::semantic_type* yylval, yy::parser::location_type* yylloc) {
    yylloc->begin.line = lexer->lineno();
    int token = lexer->yylex();
    if(token == yy::parser::token::ID || token == yy::parser::token::NUM) {
        yylval->build(std::string(lexer->YYText()));
    }
    return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0xd325(%rip), %rdi      # 0x12228
movl 0x14(%rdi), %eax
movl %eax, 0x8(%rsi)
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, %ebx
leal -0x115(%rbx), %eax
cmpl $0x1, %eax
ja 0x4f69
movq 0xd305(%rip), %rax      # 0x12228
movq 0x8(%rax), %rsi
leaq -0x40(%rbp), %r15
leaq -0x19(%rbp), %rdx
movq %r15, %rdi
callq 0x521c
leaq 0x10(%r14), %rax
movq %rax, (%r14)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x52f4
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4f69
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3240
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4f92
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3240
movq %rbx, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/while.tab.cc
// Function: yy::parser::stack_symbol_type::stack_symbol_type(yy::parser::stack_symbol_type&&)
parser::stack_symbol_type::stack_symbol_type (YY_RVREF (stack_symbol_type) that)
    : super_type (YY_MOVE (that.state), YY_MOVE (that.location))
  {
    switch (that.kind ())
    {
      case symbol_kind::S_expression: // expression
        value.YY_MOVE_OR_COPY< expression* > (YY_MOVE (that.value));
        break;

      case symbol_kind::S_command: // command
        value.YY_MOVE_OR_COPY< instruction* > (YY_MOVE (that.value));
        break;

      case symbol_kind::S_commands: // commands
        value.YY_MOVE_OR_COPY< std::list<instruction*>*  > (YY_MOVE (that.value));
        break;

      case symbol_kind::S_ID: // ID
      case symbol_kind::S_NUM: // NUM
        value.YY_MOVE_OR_COPY< std::string > (YY_MOVE (that.value));
        break;

      default:
        break;
    }

#if 201103L <= YY_CPLUSPLUS
    // that is emptied.
    that.state = empty_state;
#endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb (%rsi), %al
movb %al, (%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps 0x30(%rsi), %xmm0
movaps 0x40(%rsi), %xmm1
movaps %xmm1, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movsbq (%rsi), %rax
testq %rax, %rax
je 0x5587
leaq 0x769f(%rip), %rcx      # 0xcc20
movsbl (%rax,%rcx), %ecx
jmp 0x558c
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
leaq 0x10(%rdi), %rax
cmpl $0x29, %ecx
jg 0x55bd
leal -0x16(%rcx), %edx
cmpl $0x2, %edx
jae 0x55c9
leaq 0x20(%rdi), %rdx
movq %rdx, 0x10(%rdi)
movq 0x10(%rsi), %r8
leaq 0x20(%rsi), %rcx
cmpq %rcx, %r8
je 0x55d7
movq %r8, (%rax)
movq (%rcx), %rax
movq %rax, (%rdx)
jmp 0x55dd
cmpl $0x2a, %ecx
je 0x55ce
cmpl $0x2b, %ecx
je 0x55ce
jmp 0x55f5
cmpl $0x29, %ecx
jne 0x55f5
movq 0x10(%rsi), %rcx
movq %rcx, (%rax)
jmp 0x55f5
movaps (%rcx), %xmm0
movaps %xmm0, (%rdx)
movq 0x18(%rsi), %rax
movq %rax, 0x18(%rdi)
movq %rcx, 0x10(%rsi)
movq $0x0, 0x18(%rsi)
movb $0x0, 0x20(%rsi)
movb $0x0, (%rsi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/while.tab.cc
// Function: yy::parser::stack_symbol_type::stack_symbol_type(signed char, yy::parser::symbol_type&&)
parser::stack_symbol_type::stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) that)
    : super_type (s, YY_MOVE (that.location))
  {
    switch (that.kind ())
    {
      case symbol_kind::S_expression: // expression
        value.move< expression* > (YY_MOVE (that.value));
        break;

      case symbol_kind::S_command: // command
        value.move< instruction* > (YY_MOVE (that.value));
        break;

      case symbol_kind::S_commands: // commands
        value.move< std::list<instruction*>*  > (YY_MOVE (that.value));
        break;

      case symbol_kind::S_ID: // ID
      case symbol_kind::S_NUM: // NUM
        value.move< std::string > (YY_MOVE (that.value));
        break;

      default:
        break;
    }

    // that is emptied.
    that.kind_ = symbol_kind::S_YYEMPTY;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, (%rdi)
leaq 0x10(%rdi), %rax
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps 0x30(%rdx), %xmm0
movaps 0x40(%rdx), %xmm1
movaps %xmm1, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movl (%rdx), %ecx
cmpl $0x29, %ecx
jg 0x564f
leal -0x16(%rcx), %esi
cmpl $0x2, %esi
jae 0x565b
leaq 0x20(%rdi), %rsi
movq %rsi, 0x10(%rdi)
movq 0x10(%rdx), %r8
leaq 0x20(%rdx), %rcx
cmpq %rcx, %r8
je 0x5669
movq %r8, (%rax)
movq (%rcx), %rax
movq %rax, (%rsi)
jmp 0x566f
cmpl $0x2a, %ecx
je 0x5660
cmpl $0x2b, %ecx
je 0x5660
jmp 0x5687
cmpl $0x29, %ecx
jne 0x5687
movq 0x10(%rdx), %rcx
movq %rcx, (%rax)
jmp 0x5687
movaps (%rcx), %xmm0
movaps %xmm0, (%rsi)
movq 0x18(%rdx), %rax
movq %rax, 0x18(%rdi)
movq %rcx, 0x10(%rdx)
movq $0x0, 0x18(%rdx)
movb $0x0, 0x20(%rdx)
movl $0xfffffffe, (%rdx)     # imm = 0xFFFFFFFE
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/while.tab.cc
// Function: yy::parser::yypush_(char const*, signed char, yy::parser::symbol_type&&)
void
  parser::yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym)
  {
#if 201103L <= YY_CPLUSPLUS
    yypush_ (m, stack_symbol_type (s, std::move (sym)));
#else
    stack_symbol_type ss (s, sym);
    yypush_ (m, ss);
#endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq -0x60(%rbp), %r14
movq %r14, %rdi
movl %edx, %esi
movq %rcx, %rdx
callq 0x55fa
addq $0x8, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6f6a
leaq -0x60(%rbp), %rdi
callq 0x714a
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x714a
movq %rbx, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/while.tab.cc
// Function: yy::parser::yy_lr_goto_state_(signed char, int)
parser::state_type
  parser::yy_lr_goto_state_ (state_type yystate, int yysym)
  {
    int yyr = yypgoto_[yysym - YYNTOKENS] + yystate;
    if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate)
      return yytable_[yyr];
    else
      return yydefgoto_[yysym - YYNTOKENS];
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %esi, %rax
leaq 0x7350(%rip), %rcx      # 0xca88
movsbl -0x25(%rax,%rcx), %ecx
addl %edi, %ecx
cmpl $0xb9, %ecx
ja 0x5762
movl %ecx, %edx
leaq 0x7410(%rip), %rcx      # 0xcb60
cmpb %dil, (%rdx,%rcx)
jne 0x5762
leaq 0x7343(%rip), %rcx      # 0xcaa0
addq %rdx, %rcx
jmp 0x5770
addq $-0x25, %rax
leaq 0x7322(%rip), %rcx      # 0xca8f
addq %rax, %rcx
movb (%rcx), %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/while.tab.cc
// Function: yy::parser::basic_symbol<yy::parser::by_state>::move(yy::parser::basic_symbol<yy::parser::by_state>&)
void
  parser::basic_symbol<Base>::move (basic_symbol& s)
  {
    super_type::move (s);
    switch (this->kind ())
    {
      case symbol_kind::S_expression: // expression
        value.move< expression* > (YY_MOVE (s.value));
        break;

      case symbol_kind::S_command: // command
        value.move< instruction* > (YY_MOVE (s.value));
        break;

      case symbol_kind::S_commands: // commands
        value.move< std::list<instruction*>*  > (YY_MOVE (s.value));
        break;

      case symbol_kind::S_ID: // ID
      case symbol_kind::S_NUM: // NUM
        value.move< std::string > (YY_MOVE (s.value));
        break;

      default:
        break;
    }

    location = YY_MOVE (s.location);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb (%rsi), %al
movb %al, (%rdi)
movb $0x0, (%rsi)
movsbq (%rdi), %rax
testq %rax, %rax
je 0x71af
leaq 0x5a77(%rip), %rcx      # 0xcc20
movsbl (%rax,%rcx), %eax
jmp 0x71b4
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
cmpl $0x29, %eax
jg 0x71e3
leal -0x16(%rax), %ecx
cmpl $0x2, %ecx
jae 0x71ef
leaq 0x20(%rdi), %rcx
movq %rcx, 0x10(%rdi)
movq 0x10(%rsi), %rdx
leaq 0x20(%rsi), %rax
cmpq %rax, %rdx
je 0x71fe
movq %rdx, 0x10(%rdi)
movq (%rax), %rcx
movq %rcx, 0x20(%rdi)
jmp 0x7204
cmpl $0x2a, %eax
je 0x71f4
cmpl $0x2b, %eax
je 0x71f4
jmp 0x721c
cmpl $0x29, %eax
jne 0x721c
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
jmp 0x721c
movaps (%rax), %xmm0
movaps %xmm0, (%rcx)
movq 0x18(%rsi), %rcx
movq %rcx, 0x18(%rdi)
movq %rax, 0x10(%rsi)
movq $0x0, 0x18(%rsi)
movb $0x0, 0x20(%rsi)
movaps 0x30(%rsi), %xmm0
movaps 0x40(%rsi), %xmm1
movaps %xmm1, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
popq %rbp
retq