LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::Value::CZString::CZString(Json::Value::CZString const&)
Value::CZString::CZString(const CZString& other)
    : cstr_(other.storage_.policy_ != noDuplication && other.cstr_ != 0
                ? duplicateStringValue(other.cstr_, other.storage_.length_)
                : other.cstr_)
{
  storage_.policy_ = (other.cstr_
                 ? (other.storage_.policy_ == noDuplication
                     ? noDuplication : duplicate)
                 : other.storage_.policy_);
  storage_.length_ = other.storage_.length_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %r15d
testb $0x3, %r15b
je 0x4f82a
movq (%r14), %r12
testq %r12, %r12
je 0x4f82a
shrl $0x2, %r15d
leaq 0x1(%r15), %rdi
callq 0x2ff90
testq %rax, %rax
je 0x4f868
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2f3d0
movb $0x0, (%r13,%r15)
jmp 0x4f82d
movq (%r14), %r13
movq %r13, (%rbx)
movl 0x8(%r14), %eax
xorl %ecx, %ecx
andl $0x3, %eax
setne %cl
cmpq $0x0, (%r14)
cmovel %eax, %ecx
movl 0x8(%rbx), %eax
andl $-0x4, %eax
orl %ecx, %eax
movl %eax, 0x8(%rbx)
movl 0x8(%r14), %eax
andl $-0x4, %eax
orl %ecx, %eax
movl %eax, 0x8(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xe7d2(%rip), %rsi      # 0x5e04a
leaq 0xe819(%rip), %rdx      # 0x5e098
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x2e860
movq %rbx, %rdi
callq 0x2f490
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x4f8a3
callq 0x2f6c0
movq %rbx, %rdi
callq 0x30a20
nop
// File: /workspace/github_cpp_makefile_star2_O1/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::Value::Value(Json::ValueType)
void Value::initBasic(ValueType type, bool allocated) {
  type_ = type;
  allocated_ = allocated;
  comments_ = 0;
  start_ = 0;
  limit_ = 0;
}

// Assembly:
pushq %rbx
movzbl %sil, %eax
movl $0xfffffe00, %ecx       # imm = 0xFFFFFE00
andl 0x8(%rdi), %ecx
orl %eax, %ecx
movw %cx, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
cmpl $0x7, %esi
ja 0x4f9fb
movq %rdi, %rbx
movl %esi, %eax
leaq 0xd4ed(%rip), %rcx      # 0x5cea0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x0, (%rbx)
jmp 0x4f9f9
movl $0x30, %edi
callq 0x2f830
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq %rax, (%rbx)
jmp 0x4f9f9
movb $0x0, (%rbx)
popq %rbx
retq
leaq 0xdd04(%rip), %rdi      # 0x5d706
leaq 0xd8c1(%rip), %rsi      # 0x5d2ca
leaq 0xdcfc(%rip), %rcx      # 0x5d70c
movl $0xa9c, %edx            # imm = 0xA9C
callq 0x2efc0
// File: /workspace/github_cpp_makefile_star2_O1/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::Value::getString(char const**, char const**) const
bool Value::getString(char const** str, char const** end) const {
  if (type_ != stringValue) return false;
  if (value_.string_ == 0) return false;
  unsigned length;
  decodePrefixedString(this->allocated_, this->value_.string_, &length, str);
  *end = *str + length;
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movzwl 0x8(%rdi), %eax
cmpb $0x4, %al
sete %cl
movq (%rdi), %r15
testq %r15, %r15
setne %bpl
andb %cl, %bpl
cmpb $0x1, %bpl
jne 0x50357
movq %rdx, %rbx
movq %rsi, %r14
btl $0x8, %eax
jb 0x50345
movq %r15, %rdi
callq 0x2e980
jmp 0x5034c
movl (%r15), %eax
addq $0x4, %r15
movq %r15, (%r14)
movl %eax, %eax
addq %r15, %rax
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::valueToString[abi:cxx11](long long)
std::string valueToString(LargestInt value) {
  UIntToStringBuffer buffer;
  char* current = buffer + sizeof(buffer);
  bool isNegative = value < 0;
  if (isNegative)
    value = -value;
  uintToString(LargestUInt(value), current);
  if (isNegative)
    *--current = '-';
  assert(current >= buffer);
  return current;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rcx
movq %rsi, %r8
negq %r8
cmovsq %rsi, %r8
movq %rdi, %rbx
leaq 0x27(%rsp), %rsi
movb $0x0, 0x1(%rsi)
movabsq $-0x3333333333333333, %rdi # imm = 0xCCCCCCCCCCCCCCCD
movq %r8, %rax
mulq %rdi
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %r8d, %r9d
subl %eax, %r9d
orb $0x30, %r9b
movb %r9b, (%rsi)
decq %rsi
cmpq $0x9, %r8
movq %rdx, %r8
ja 0x5038c
testq %rcx, %rcx
js 0x503bf
incq %rsi
jmp 0x503c2
movb $0x2d, (%rsi)
leaq 0x10(%rsp), %rax
cmpq %rax, %rsi
jb 0x503e2
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x2e880
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
leaq 0xd967(%rip), %rdi      # 0x5dd50
leaq 0xceda(%rip), %rsi      # 0x5d2ca
leaq 0xd96b(%rip), %rcx      # 0x5dd62
movl $0xfb2, %edx            # imm = 0xFB2
callq 0x2efc0
// File: /workspace/github_cpp_makefile_star2_O1/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::valueToString[abi:cxx11](double)
std::string valueToString(double value) {
  // Allocate a buffer that is more than large enough to store the 16 digits of
  // precision requested below.
  char buffer[32];
  int len = -1;

// Print into the buffer. We need not request the alternative representation
// that always has a decimal point because JSON doesn't distingish the
// concepts of reals and integers.
#if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__) // Use secure version with
                                                      // visual studio 2005 to
                                                      // avoid warning.
#if defined(WINCE)
  len = _snprintf(buffer, sizeof(buffer), "%.17g", value);
#else
  len = sprintf_s(buffer, sizeof(buffer), "%.17g", value);
#endif
#else
  if (isfinite(value)) {
    len = snprintf(buffer, sizeof(buffer), "%.17g", value);
  } else {
    // IEEE standard states that NaN values will not compare to themselves
    if (value != value) {
      len = snprintf(buffer, sizeof(buffer), "null");
    } else if (value < 0) {
      len = snprintf(buffer, sizeof(buffer), "-1e+9999");
    } else {
      len = snprintf(buffer, sizeof(buffer), "1e+9999");
    }
    // For those, we do not need to call fixNumLoc, but it is fast.
  }
#endif
  assert(len >= 0);
  fixNumericLocale(buffer, buffer + len);
  return buffer;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
cmpq %rcx, %rax
jle 0x504d8
ucomisd %xmm0, %xmm0
jp 0x5056a
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x504f0
movabsq $0x393939392b65312d, %rax # imm = 0x393939392B65312D
movq %rax, (%rsp)
movb $0x0, 0x8(%rsp)
movl $0x8, %eax
jmp 0x50503
leaq 0xd8dc(%rip), %rdx      # 0x5ddbb
movq %rsp, %rdi
movl $0x20, %esi
movb $0x1, %al
callq 0x30650
jmp 0x50503
movabsq $0x393939392b6531, %rax # imm = 0x393939392B6531
movq %rax, (%rsp)
movl $0x7, %eax
testl %eax, %eax
js 0x5054b
je 0x5051f
movl %eax, %eax
xorl %ecx, %ecx
cmpb $0x2c, (%rsp,%rcx)
jne 0x50517
movb $0x2e, (%rsp,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x5050d
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rsp, %r14
movq %r14, %rdi
callq 0x2e980
leaq (%rsp,%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2e860
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0xd87d(%rip), %rdi      # 0x5ddcf
leaq 0xcd71(%rip), %rsi      # 0x5d2ca
leaq 0xd878(%rip), %rcx      # 0x5ddd8
movl $0xfea, %edx            # imm = 0xFEA
callq 0x2efc0
movb $0x0, 0x4(%rsp)
movl $0x6c6c756e, (%rsp)     # imm = 0x6C6C756E
movl $0x4, %eax
jmp 0x50503
nop
// File: /workspace/github_cpp_makefile_star2_O1/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::Value::asFloat() const
float Value::asFloat() const {
  switch (type_) {
  case intValue:
    return static_cast<float>(value_.int_);
  case uintValue:
#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
    return static_cast<float>(value_.uint_);
#else  // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
    return integerToDouble(value_.uint_);
#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
  case realValue:
    return static_cast<float>(value_.real_);
  case nullValue:
    return 0.0;
  case booleanValue:
    return value_.bool_ ? 1.0f : 0.0f;
  default:
    break;
  }
  JSON_FAIL_MESSAGE("Value is not convertible to float.");
}

// Assembly:
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movzbl 0x8(%rdi), %eax
cmpq $0x5, %rax
ja 0x50d00
leaq 0xc2b7(%rip), %rcx      # 0x5cf60
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cvtsi2ssq (%rdi), %xmm0
jmp 0x50cf7
cmpb $0x0, (%rdi)
jne 0x50cd8
xorps %xmm0, %xmm0
jmp 0x50cf7
movq (%rdi), %rax
testq %rax, %rax
js 0x50ce2
cvtsi2ss %rax, %xmm0
jmp 0x50cf7
cvtsd2ss (%rdi), %xmm0
jmp 0x50cf7
movss 0xc540(%rip), %xmm0     # 0x5d220
jmp 0x50cf7
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x2ffe0
leaq 0xccd0(%rip), %rsi      # 0x5d9e4
movl $0x22, %edx
movq %rbx, %rdi
callq 0x2fb20
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x305d0
leaq 0x8(%rsp), %rdi
callq 0x30350
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x50d57
callq 0x2f6c0
jmp 0x50d57
jmp 0x50d54
movq %rax, %rbx
movq 0x2108a(%rip), %rsi     # 0x71de8
leaq 0x28(%rsp), %rdi
callq 0x2ec30
leaq 0x98(%rsp), %rdi
callq 0x2e700
movq %rbx, %rdi
callq 0x30a20
nop
// File: /workspace/github_cpp_makefile_star2_O1/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::Value::find(char const*, char const*) const
Value const* Value::find(char const* key, char const* end) const
{
  JSON_ASSERT_MESSAGE(
      type_ == nullValue || type_ == objectValue,
      "in Json::Value::find(key, end, found): requires objectValue or nullValue");
  if (type_ == nullValue) return NULL;
  CZString actualKey(key, static_cast<unsigned>(end-key), CZString::noDuplication);
  ObjectValues::const_iterator it = value_.map_->find(actualKey);
  if (it == value_.map_->end()) return NULL;
  return &(*it).second;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movzbl 0x8(%rdi), %eax
testl %eax, %eax
je 0x51bae
cmpl $0x7, %eax
jne 0x51bbe
movq %rdi, %rbx
subl %esi, %edx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x2f7c0
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x31020
movq (%rbx), %rcx
addq $0x8, %rcx
leaq 0x30(%rax), %rdx
xorl %ebx, %ebx
cmpq %rcx, %rax
cmovneq %rdx, %rbx
leaq 0x20(%rsp), %rdi
callq 0x301e0
jmp 0x51bb0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x2ffe0
leaq 0xc0c1(%rip), %rsi      # 0x5dc93
movl $0x48, %edx
movq %rbx, %rdi
callq 0x2fb20
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x305d0
movq %rsp, %rdi
callq 0x30350
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x51c11
callq 0x2f6c0
jmp 0x51c11
jmp 0x51c0e
movq %rax, %rbx
movq 0x201d0(%rip), %rsi     # 0x71de8
leaq 0x20(%rsp), %rdi
callq 0x2ec30
leaq 0x90(%rsp), %rdi
callq 0x2e700
jmp 0x51c3e
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x301e0
movq %rbx, %rdi
callq 0x30a20
// File: /workspace/github_cpp_makefile_star2_O1/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::Value::removeMember(char const*, char const*, Json::Value*)
bool Value::removeMember(const char* key, const char* end, Value* removed)
{
  if (type_ != objectValue) {
    return false;
  }
  CZString actualKey(key, static_cast<unsigned>(end-key), CZString::noDuplication);
  ObjectValues::iterator it = value_.map_->find(actualKey);
  if (it == value_.map_->end())
    return false;
  *removed = it->second;
  value_.map_->erase(it);
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
cmpb $0x7, 0x8(%rdi)
jne 0x51edb
movq %rcx, %r14
movq %rdi, %rbx
subl %esi, %edx
movq %rsp, %r15
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x2f7c0
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x31020
movq %rax, %r15
movq (%rbx), %rax
addq $0x8, %rax
cmpq %rax, %r15
setne %bpl
je 0x51ed1
leaq 0x30(%r15), %rsi
leaq 0x10(%rsp), %rdi
callq 0x30690
movzwl 0x8(%r14), %eax
movl $0xff, %edx
movl %eax, %esi
andl %edx, %esi
leaq 0x10(%rsp), %rdi
movzwl 0x8(%rdi), %r8d
andl %r8d, %edx
movl $0xff00, %ecx           # imm = 0xFF00
movl %eax, %r9d
andl %ecx, %r9d
orl %edx, %r9d
movw %r9w, 0x8(%r14)
andl %r8d, %ecx
orl %esi, %ecx
movw %cx, 0x8(%rdi)
movq (%r14), %rdx
movq (%rdi), %rsi
movq %rsi, (%r14)
movq %rdx, (%rdi)
movl $0x100, %edx            # imm = 0x100
andl %edx, %eax
andl %edx, %r8d
andl $0xfeff, %r9d           # imm = 0xFEFF
orl %r8d, %r9d
movw %r9w, 0x8(%r14)
andl $0xfffffeff, %ecx       # imm = 0xFFFFFEFF
orl %eax, %ecx
movw %cx, 0x8(%rdi)
movq 0x10(%r14), %rax
movq 0x10(%rdi), %rcx
movq %rcx, 0x10(%r14)
movq %rax, 0x10(%rdi)
movq 0x18(%r14), %rax
movq 0x18(%rdi), %rcx
movq %rcx, 0x18(%r14)
movq %rax, 0x18(%rdi)
movq 0x20(%r14), %rax
movq 0x20(%rdi), %rcx
movq %rcx, 0x20(%r14)
movq %rax, 0x20(%rdi)
callq 0x2ebb0
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x308a0
movq %rsp, %rdi
callq 0x301e0
jmp 0x51edd
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x301e0
movq %rbx, %rdi
callq 0x30a20
nop
// File: /workspace/github_cpp_makefile_star2_O1/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::Value::begin() const
Value::const_iterator Value::begin() const {
  switch (type_) {
  case arrayValue:
  case objectValue:
    if (value_.map_)
      return const_iterator(value_.map_->begin());
    break;
  default:
    break;
  }
  return const_iterator();
}

// Assembly:
subq $0x18, %rsp
movzwl 0x8(%rdi), %eax
andl $0xfe, %eax
cmpw $0x6, %ax
setne %cl
movq (%rdi), %rax
testq %rax, %rax
sete %dl
orb %cl, %dl
je 0x525b3
movq %rsp, %rdi
callq 0x305a0
jmp 0x525c7
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %rdi
callq 0x30fc0
movq (%rsp), %rax
movb 0x8(%rsp), %dl
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::Value::end() const
Value::const_iterator Value::end() const {
  switch (type_) {
  case arrayValue:
  case objectValue:
    if (value_.map_)
      return const_iterator(value_.map_->end());
    break;
  default:
    break;
  }
  return const_iterator();
}

// Assembly:
subq $0x18, %rsp
movzwl 0x8(%rdi), %eax
andl $0xfe, %eax
cmpw $0x6, %ax
setne %cl
movq (%rdi), %rax
testq %rax, %rax
sete %dl
orb %cl, %dl
je 0x525ff
movq %rsp, %rdi
callq 0x305a0
jmp 0x52613
addq $0x8, %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %rdi
callq 0x30fc0
movq (%rsp), %rax
movb 0x8(%rsp), %dl
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::Value::begin()
Value::iterator Value::begin() {
  switch (type_) {
  case arrayValue:
  case objectValue:
    if (value_.map_)
      return iterator(value_.map_->begin());
    break;
  default:
    break;
  }
  return iterator();
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movzwl 0x8(%rsi), %eax
andl $0xfe, %eax
cmpw $0x6, %ax
setne %cl
movq (%rsi), %rax
testq %rax, %rax
sete %dl
orb %cl, %dl
je 0x5264f
movq %rbx, %rdi
callq 0x302b0
jmp 0x52663
movq 0x18(%rax), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x2eaa0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::Value::end()
Value::iterator Value::end() {
  switch (type_) {
  case arrayValue:
  case objectValue:
    if (value_.map_)
      return iterator(value_.map_->end());
    break;
  default:
    break;
  }
  return iterator();
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movzwl 0x8(%rsi), %eax
andl $0xfe, %eax
cmpw $0x6, %ax
setne %cl
movq (%rsi), %rax
testq %rax, %rax
sete %dl
orb %cl, %dl
je 0x5269b
movq %rbx, %rdi
callq 0x302b0
jmp 0x526af
addq $0x8, %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x2eaa0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::StyledWriter::isMultineArray(Json::Value const&)
bool StyledWriter::isMultineArray(const Value& value) {
  int size = value.size();
  bool isMultiLine = size * 3 >= rightMargin_;
  childValues_.clear();
  for (int index = 0; index < size && !isMultiLine; ++index) {
    const Value& childValue = value[index];
    isMultiLine =
        isMultiLine || ((childValue.isArray() || childValue.isObject()) &&
                        childValue.size() > 0);
  }
  if (!isMultiLine) // check if line length > max line length
  {
    childValues_.reserve(size);
    addChildValues_ = true;
    int lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
    for (int index = 0; index < size; ++index) {
      if (hasCommentForValue(value[index])) {
        isMultiLine = true;
      }
      writeValue(value[index]);
      lineLength += int(childValues_[index].length());
    }
    addChildValues_ = false;
    isMultiLine = isMultiLine || lineLength >= rightMargin_;
  }
  return isMultiLine;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x30730
movl %eax, %r15d
leal (%r15,%r15,2), %eax
cmpl 0x60(%rbx), %eax
setge %bpl
leaq 0x8(%rbx), %r12
movq %r12, %rdi
callq 0x2f720
testl %r15d, %r15d
setle %al
orb %bpl, %al
testb $0x1, %al
jne 0x54472
movl $0x1, %r13d
leal -0x1(%r13), %esi
movq %r14, %rdi
callq 0x2e3c0
testb $0x1, %bpl
movb $0x1, %bpl
jne 0x54465
movzwl 0x8(%rax), %ecx
andl $0xfe, %ecx
cmpw $0x6, %cx
jne 0x54463
movq %rax, %rdi
callq 0x30730
testl %eax, %eax
setne %bpl
jmp 0x54465
xorl %ebp, %ebp
cmpl %r15d, %r13d
jge 0x54472
incl %r13d
testb %bpl, %bpl
je 0x5442e
testb %bpl, %bpl
jne 0x54523
movslq %r15d, %rsi
movq %r12, %rdi
callq 0x2fdb0
movb $0x1, 0x68(%rbx)
leal 0x2(,%r15,2), %r12d
testl %r15d, %r15d
jle 0x54513
movl %r15d, %eax
movq %rax, (%rsp)
movl $0x8, %r13d
xorl %r15d, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x2e3c0
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x544d8
cmpq $0x0, (%rcx)
setne %al
jne 0x544da
cmpq $0x0, 0x8(%rcx)
setne %al
jne 0x544da
cmpq $0x0, 0x10(%rcx)
setne %al
jmp 0x544da
xorl %eax, %eax
movzbl %bpl, %ebp
testb %al, %al
movl $0x1, %eax
cmovnel %eax, %ebp
movq %r14, %rdi
movl %r15d, %esi
callq 0x2e3c0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2ed50
movq 0x8(%rbx), %rax
addl (%rax,%r13), %r12d
incq %r15
addq $0x20, %r13
cmpq %r15, (%rsp)
jne 0x544a7
movb $0x0, 0x68(%rbx)
cmpl 0x60(%rbx), %r12d
setge %al
orb %bpl, %al
movl %eax, %ebp
andb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/tokenizer.cc
// Function: tok::Tokenizer::next_string(char)
Token Tokenizer::next_string(char strstart) {
	std::string *str = new std::string("");
	pos++;
	while (pos < source.length()) {
		char c = source[pos++];
		if (c == '\\') {
			char c = source[pos++];
			switch (c) {
			case 'n': c = '\n'; break;
			case 't': c = '\t'; break;
			case 'r': c = '\r'; break;
			case '"': c = '"';  break;
			case '\'': c = '\''; break;
			default:
				throw utils::tokenizer_error("not escapeable", line, c);
			}
		} else if (c == strstart)
			break;
		*str += c;
	}
	return Token(String, str, line);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x20, %edi
callq 0x5380
movq %rax, %rbx
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x109c8(%rip), %rdx     # 0x17104
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x6684
movq (%r14), %rax
movq 0x10(%r14), %rcx
incq %rax
movq %rax, (%r14)
cmpq 0x8(%rcx), %rax
jae 0x67b9
movl $0x51, %r15d
leaq 0x1(%rax), %rdx
movq %rdx, (%r14)
movq (%rcx), %rdx
movb (%rdx,%rax), %cl
cmpb $0x5c, %cl
jne 0x679c
leaq 0x2(%rax), %rsi
movq %rsi, (%r14)
movb 0x1(%rdx,%rax), %r12b
movzbl %r12b, %eax
leal -0x6e(%rax), %edx
cmpl $0x6, %edx
ja 0x6790
btl %edx, %r15d
jb 0x67a1
cmpl $0x22, %eax
je 0x67a1
cmpl $0x27, %eax
je 0x67a1
jmp 0x67d1
cmpb %bpl, %cl
je 0x67b9
movsbl %cl, %esi
movq %rbx, %rdi
callq 0x5300
movq (%r14), %rax
movq 0x10(%r14), %rcx
cmpq 0x8(%rcx), %rax
jb 0x6760
movl 0x8(%r14), %eax
shlq $0x20, %rax
orq $0x3, %rax
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0x51b0
movq %rax, %rbx
movl 0x8(%r14), %edx
movsbl %r12b, %ecx
leaq 0x10c62(%rip), %rsi     # 0x1744f
movq %rax, %rdi
callq 0xa838
leaq 0x19d3c(%rip), %rsi     # 0x20538
leaq 0x1303(%rip), %rdx      # 0x7b06
movq %rbx, %rdi
callq 0x55d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
jmp 0x6828
movq %rax, %r14
movl $0x20, %esi
movq %rbx, %rdi
callq 0x5390
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/tokenizer.cc
// Function: tok::Tokenizer::next_number()
Token Tokenizer::next_number() {
	std::string str = "";
	bool contains_dot = false;
	char c = source[pos];
	while (('0' <= c && c <= '9') || c == '.' || (c >= 'a' && c <= 'z')) {
		str += c;
		if (c == '.')
			contains_dot = true;
		if (++pos >= source.length())
			break;
		c = source[pos];
	}

	if (contains_dot)
		return Token(Real, std::stod(str, nullptr), line);
	else
		return Token(Int, std::stoi(str, nullptr, 0), line);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x108b3(%rip), %rdx     # 0x17104
leaq 0x10(%rsp), %rdi
movq %rdx, %rsi
callq 0x6684
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
movb (%rcx,%rax), %al
cmpb $0x2e, %al
sete %bpl
je 0x6887
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
jb 0x6887
leal -0x61(%rax), %ecx
cmpb $0x19, %cl
ja 0x692a
xorl %r15d, %r15d
leaq 0x10(%rsp), %r14
movl $0x1, %r12d
movsbl %al, %esi
movq %r14, %rdi
callq 0x5300
movzbl %r15b, %r15d
testb $0x1, %bpl
cmovnel %r12d, %r15d
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
incq %rax
movq %rax, (%rbx)
cmpq 0x8(%rcx), %rax
jae 0x68dd
movq (%rcx), %rcx
movb (%rcx,%rax), %al
cmpb $0x2e, %al
sete %bpl
je 0x6895
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
jb 0x6895
leal -0x61(%rax), %ecx
cmpb $0x1a, %cl
jb 0x6895
testb $0x1, %r15b
je 0x692a
movq 0x10(%rsp), %r15
callq 0x5050
movq %rax, %r14
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x30(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x52c0
cmpq %r15, (%r12)
je 0x69dc
movl (%r14), %eax
testl %eax, %eax
je 0x697d
cmpl $0x22, %eax
jne 0x6980
leaq 0x10c74(%rip), %rdi     # 0x17599
callq 0x54f0
movq 0x10(%rsp), %r15
callq 0x5050
movq %rax, %r14
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x30(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x54e0
cmpq %r15, (%r12)
je 0x69c4
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x69d0
movl (%r14), %ecx
cmpl $0x22, %ecx
je 0x69d0
testl %ecx, %ecx
jne 0x696e
movl %ebp, (%r14)
movl 0x8(%rbx), %ebx
movl %eax, 0x8(%rsp)
movl $0x1, %r14d
jmp 0x698f
movl %ebp, (%r14)
movl 0x8(%rbx), %ebx
movsd %xmm0, 0x8(%rsp)
movl $0x2, %r14d
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x69a6
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x5390
shlq $0x20, %rbx
orq %r14, %rbx
movq 0x8(%rsp), %rdx
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10bd3(%rip), %rdi     # 0x1759e
callq 0x5200
leaq 0x10bc7(%rip), %rdi     # 0x1759e
callq 0x54f0
leaq 0x10bb6(%rip), %rdi     # 0x17599
callq 0x5200
jmp 0x69ea
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x69fb
movl %ebp, (%r14)
jmp 0x69fb
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x6a12
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/tokenizer.cc
// Function: tok::Tokenizer::peek()
Token Tokenizer::peek() {
	if (tokbuffed)
		return tokbuf;

	tokbuf = next();
	tokbuffed = true;
	return tokbuf;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x28(%rdi)
jne 0x6a2e
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rdx
jmp 0x6a42
movq %rbx, %rdi
callq 0x6a44
movq %rax, 0x18(%rbx)
movq %rdx, 0x20(%rbx)
movb $0x1, 0x28(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/parser.cc
// Function: asbi::Parser::parse()
ast::Node* Parser::parse() {
	std::vector<ast::Node*> parsed;
	while (tokenizer.peek().type != tok::EOFTok) {
		parsed.push_back(next());
	}

	return parsed.size() == 1 ? parsed[0] : new ast::Block(parsed);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0x38(%rsp), %r15
movq %rbx, %rdi
callq 0x6a1a
cmpl $0x25, %eax
je 0x81be
movq %rbx, %rdi
callq 0x82a2
movq %rax, 0x38(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xa2f6
jmp 0x8197
movq (%rsp), %rax
movq 0x8(%rsp), %r14
subq %rax, %r14
cmpq $0x8, %r14
jne 0x81d5
movq (%rax), %rbx
jmp 0x820e
movl $0x20, %edi
callq 0x5380
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0xa00e
leaq 0x18942(%rip), %rax     # 0x20b38
addq $0x10, %rax
movq %rax, (%rbx)
movq %rbx, %rdi
addq $0x8, %rdi
leaq 0x20(%rsp), %rsi
callq 0xa00e
cmpq $0x8, %r14
je 0x822b
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x822b
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x5390
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8241
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x5390
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x826d
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x5390
jmp 0x826d
movq %rax, %r14
movl $0x20, %esi
movq %rbx, %rdi
callq 0x5390
jmp 0x8283
jmp 0x8280
jmp 0x8280
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8299
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x5390
movq %r14, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/parser.cc
// Function: asbi::Parser::next()
ast::Node* Parser::next() {
	auto node = parse_expr();
	auto t = tokenizer.peek().type;
	if (t == tok::EOFTok)
		return node;

	if (t == tok::Semicolon) {
		tokenizer.next();
		return node;
	}

	throw utils::parser_error("expected ';' or EOF", tokenizer.peek());
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x8330
movq %rax, %rbx
movq %r14, %rdi
callq 0x6a1a
cmpl $0x25, %eax
je 0x82cb
cmpl $0x1e, %eax
jne 0x82d6
movq %r14, %rdi
callq 0x6a44
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x48, %edi
callq 0x51b0
movq %rax, %rbx
movq %r14, %rdi
callq 0x6a1a
movq %rdx, %rcx
leaq 0xf410(%rip), %rsi      # 0x17705
movq %rbx, %rdi
movq %rax, %rdx
callq 0xa9f6
leaq 0x18271(%rip), %rsi     # 0x20578
leaq 0x1cd0(%rip), %rdx      # 0x9fde
movq %rbx, %rdi
callq 0x55d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/parser.cc
// Function: asbi::Parser::parse_controllflow()
ast::Node* Parser::parse_controllflow() {
	auto t = tokenizer.peek().type;
	if (t == tok::If) {
		tokenizer.next();

		auto cond = parse_assign();
		expect(tok::LeftCurlyBracket);
		auto ifbody = parse_block();
		ast::Node* elsebody = nullptr;
		if (tokenizer.peek().type == tok::Else) {
			tokenizer.next();
			if (tokenizer.peek().type == tok::If) {
				elsebody = parse_controllflow();
			} else {
				expect(tok::LeftCurlyBracket);
				elsebody = parse_block();
			}
		}

		return new ast::If(cond, ifbody, elsebody);
	}
	if (t == tok::For) {
		tokenizer.next();

		auto expr1 = parse_assign();
		if (tokenizer.peek().type == tok::Semicolon) {
			tokenizer.next();
			auto expr2 = parse_assign();
			expect(tok::Semicolon);
			auto expr3 = parse_assign();
			expect(tok::LeftCurlyBracket);
			return new ast::For(expr1, expr2, expr3, parse_block());
		}

		expect(tok::LeftCurlyBracket);
		return new ast::For(nullptr, expr1, nullptr, parse_block());
	}
	return parse_assign();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x6a1a
cmpl $0x24, %eax
je 0x83b1
cmpl $0x22, %eax
jne 0x843a
movq %rbx, %rdi
callq 0x6a44
movq %rbx, %rdi
callq 0x84f6
movq %rax, %r14
movq %rbx, %rdi
movl $0x19, %esi
callq 0x810c
movq %rbx, %rdi
callq 0x89e6
movq %rax, %r12
movq %rbx, %rdi
callq 0x6a1a
cmpl $0x23, %eax
jne 0x844b
movq %rbx, %rdi
callq 0x6a44
movq %rbx, %rdi
callq 0x6a1a
cmpl $0x22, %eax
jne 0x8490
movq %rbx, %rdi
callq 0x8330
jmp 0x84a5
movq %rbx, %rdi
callq 0x6a44
movq %rbx, %rdi
callq 0x84f6
movq %rax, %r14
movq %rbx, %rdi
callq 0x6a1a
movq %rbx, %rdi
cmpl $0x1e, %eax
jne 0x844f
callq 0x6a44
movq %rbx, %rdi
callq 0x84f6
movq %rax, %r12
movq %rbx, %rdi
movl $0x1e, %esi
callq 0x810c
movq %rbx, %rdi
callq 0x84f6
movq %rax, %r13
movq %rbx, %rdi
movl $0x19, %esi
callq 0x810c
movl $0x28, %edi
callq 0x5380
movq %rax, %r15
movq %rbx, %rdi
callq 0x89e6
leaq 0x18653(%rip), %rcx     # 0x20a78
addq $0x10, %rcx
movq %rcx, (%r15)
movq %r14, 0x8(%r15)
movq %r12, 0x10(%r15)
movq %r13, 0x18(%r15)
jmp 0x848a
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x84f6
xorl %ebx, %ebx
jmp 0x84a8
movl $0x19, %esi
callq 0x810c
movl $0x28, %edi
callq 0x5380
movq %rax, %r15
movq %rbx, %rdi
callq 0x89e6
leaq 0x18603(%rip), %rcx     # 0x20a78
addq $0x10, %rcx
movq %rcx, (%r15)
xorl %ecx, %ecx
movq %rcx, 0x8(%r15)
movq %r14, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %rax, 0x20(%r15)
jmp 0x84cf
movq %rbx, %rdi
movl $0x19, %esi
callq 0x810c
movq %rbx, %rdi
callq 0x89e6
movq %rax, %rbx
movl $0x20, %edi
callq 0x5380
movq %rax, %r15
leaq 0x1858c(%rip), %rax     # 0x20a48
addq $0x10, %rax
movq %rax, (%r15)
movq %r14, 0x8(%r15)
movq %r12, 0x10(%r15)
movq %rbx, 0x18(%r15)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x84de
movq %rax, %rbx
movl $0x28, %esi
movq %r15, %rdi
callq 0x5390
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/parser.cc
// Function: asbi::Parser::parse_logic()
ast::Node* Parser::parse_logic() {
	auto left = parse_cmp();
	auto t = tokenizer.peek().type;
	while (t == tok::Or || t == tok::And) {
		tokenizer.next();
		auto right = parse_cmp();
		if (t == tok::Or)
			left = new ast::InfixOperator(ast::InfixOperator::Or,  left, right);
		else
			left = new ast::InfixOperator(ast::InfixOperator::And, left, right);
		t = tokenizer.peek().type;
	}
	return left;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x8cc6
movq %rax, %r14
movq %rbx, %rdi
callq 0x6a1a
leal -0x15(%rax), %ecx
cmpl $0x1, %ecx
ja 0x8cb0
leaq 0x17a7b(%rip), %r13     # 0x206d8
addq $0x10, %r13
xorl %ebp, %ebp
cmpl $0x15, %eax
sete %bpl
movq %rbx, %rdi
callq 0x6a44
movq %rbx, %rdi
callq 0x8cc6
movq %rax, %r12
movl $0x20, %edi
callq 0x5380
movq %rax, %r15
movq %r13, (%rax)
orl $0x4, %ebp
movl %ebp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %r12, 0x18(%rax)
movq %rbx, %rdi
callq 0x6a1a
leal -0x15(%rax), %ecx
movq %r15, %r14
cmpl $0x2, %ecx
jb 0x8c61
jmp 0x8cb3
movq %r14, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/parser.cc
// Function: asbi::Parser::parse_cmp()
ast::Node* Parser::parse_cmp() {
	auto left = parse_addsub();
	auto t = tokenizer.peek().type;
	while (t == tok::Equals || t == tok::EqualsNot || t == tok::Smaller || t == tok::Bigger || t == tok::SmallerOrEqual || t == tok::BiggerOrEqual) {
		tokenizer.next();
		auto right = parse_addsub();
		if (t == tok::Equals)
			left = new ast::InfixOperator(ast::InfixOperator::Equals,    left, right);
		else if (t == tok::EqualsNot)
			left = new ast::InfixOperator(ast::InfixOperator::EqualsNot, left, right);
		else if (t == tok::Smaller)
			left = new ast::InfixOperator(ast::InfixOperator::Smaller,   left, right);
		else if (t == tok::Bigger)
			left = new ast::InfixOperator(ast::InfixOperator::Bigger,    left, right);
		else if (t == tok::SmallerOrEqual)
			left = new ast::InfixOperator(ast::InfixOperator::SmallerOrEqual, left, right);
		else if (t == tok::BiggerOrEqual)
			left = new ast::InfixOperator(ast::InfixOperator::BiggerOrEqual,  left, right);
		t = tokenizer.peek().type;
	}
	return left;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x8d68
movq %rax, %r14
movq %rbx, %rdi
callq 0x6a1a
movq %rax, %r15
addl $-0xe, %eax
cmpl $0x5, %eax
ja 0x8d55
leaq 0xe9e6(%rip), %r13      # 0x176dc
leaq 0x179db(%rip), %rbp     # 0x206d8
addq $0x10, %rbp
movq %rbx, %rdi
callq 0x6a44
movq %rbx, %rdi
callq 0x8d68
addl $-0xe, %r15d
cmpl $0x5, %r15d
ja 0x8d42
movq %rax, %r12
movl %r15d, %eax
movl (%r13,%rax,4), %r15d
movl $0x20, %edi
callq 0x5380
movq %rbp, (%rax)
movl %r15d, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %r12, 0x18(%rax)
movq %rax, %r14
movq %rbx, %rdi
callq 0x6a1a
movq %rax, %r15
addl $-0xe, %eax
cmpl $0x6, %eax
jb 0x8d01
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/parser.cc
// Function: asbi::Parser::parse_addsub()
ast::Node* Parser::parse_addsub() {
	auto left = parse_muldiv();
	auto t = tokenizer.peek().type;
	while (t == tok::Plus || t == tok::Minus) {
		tokenizer.next();
		auto right = parse_muldiv();
		if (t == tok::Plus)
			left = new ast::InfixOperator(ast::InfixOperator::Add, left, right);
		else
			left = new ast::InfixOperator(ast::InfixOperator::Sub, left, right);
		t = tokenizer.peek().type;
	}
	return left;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x8dfe
movq %rax, %r14
movq %rbx, %rdi
callq 0x6a1a
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0x8, %ecx
jne 0x8de9
leaq 0x17941(%rip), %r13     # 0x206d8
addq $0x10, %r13
xorl %ebp, %ebp
cmpl $0x8, %eax
setne %bpl
movq %rbx, %rdi
callq 0x6a44
movq %rbx, %rdi
callq 0x8dfe
movq %rax, %r12
movl $0x20, %edi
callq 0x5380
movq %rax, %r15
movq %r13, (%rax)
movl %ebp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %r12, 0x18(%rax)
movq %rbx, %rdi
callq 0x6a1a
movl %eax, %ecx
andl $-0x2, %ecx
movq %r15, %r14
cmpl $0x8, %ecx
je 0x8d9b
jmp 0x8dec
movq %r14, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/parser.cc
// Function: asbi::Parser::parse_muldiv()
ast::Node* Parser::parse_muldiv() {
	auto left = parse_unary_ops();
	auto t = tokenizer.peek().type;
	while (t == tok::Mul || t == tok::Div) {
		tokenizer.next();
		auto right = parse_unary_ops();
		if (t == tok::Mul)
			left = new ast::InfixOperator(ast::InfixOperator::Mul, left, right);
		else
			left = new ast::InfixOperator(ast::InfixOperator::Div, left, right);
		t = tokenizer.peek().type;
	}
	return left;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x8e98
movq %rax, %r14
movq %rbx, %rdi
callq 0x6a1a
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0xa, %ecx
jne 0x8e82
leaq 0x178ab(%rip), %r13     # 0x206d8
addq $0x10, %r13
xorl %ebp, %ebp
cmpl $0xa, %eax
sete %bpl
movq %rbx, %rdi
callq 0x6a44
movq %rbx, %rdi
callq 0x8e98
movq %rax, %r12
movl $0x20, %edi
callq 0x5380
movq %rax, %r15
movq %r13, (%rax)
xorl $0x3, %ebp
movl %ebp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %r12, 0x18(%rax)
movq %rbx, %rdi
callq 0x6a1a
movl %eax, %ecx
andl $-0x2, %ecx
movq %r15, %r14
cmpl $0xa, %ecx
je 0x8e31
jmp 0x8e85
movq %r14, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/parser.cc
// Function: asbi::Parser::parse_unary_ops()
ast::Node* Parser::parse_unary_ops() {
	auto t = tokenizer.peek().type;
	if (t == tok::Minus) {
		tokenizer.next();
		return new ast::PrefxOperator(ast::PrefxOperator::Neg, parse_factor());
	}
	if (t == tok::Not) {
		tokenizer.next();
		return new ast::PrefxOperator(ast::PrefxOperator::Not, parse_factor());
	}
	return parse_factor();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x6a1a
cmpl $0x14, %eax
je 0x8ee2
cmpl $0x9, %eax
jne 0x8f23
movq %r14, %rdi
callq 0x6a44
movl $0x18, %edi
callq 0x5380
movq %rax, %rbx
movq %r14, %rdi
callq 0x8f4c
leaq 0x1784e(%rip), %rcx     # 0x20720
addq $0x10, %rcx
movq %rcx, (%rbx)
movl $0x1, 0x8(%rbx)
jmp 0x8f14
movq %r14, %rdi
callq 0x6a44
movl $0x18, %edi
callq 0x5380
movq %rax, %rbx
movq %r14, %rdi
callq 0x8f4c
leaq 0x1781a(%rip), %rcx     # 0x20720
addq $0x10, %rcx
movq %rcx, (%rbx)
movl $0x0, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8f4c
jmp 0x8f34
movq %rax, %r14
movl $0x18, %esi
movq %rbx, %rdi
callq 0x5390
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/parser.cc
// Function: asbi::Parser::parse_arglist(std::vector<ast::Node*, std::allocator<ast::Node*>>&)
void Parser::parse_arglist(std::vector<ast::Node*> &args) {
	if (tokenizer.peek().type == tok::RightBracket) {
		tokenizer.next();
		return;
	}

	args.push_back(parse_expr());
	auto token = tokenizer.next();
	while (token.type == tok::Comma) {
		args.push_back(parse_expr());
		token = tokenizer.next();
	}

	if (token.type != tok::RightBracket)
		throw utils::parser_error("expected ',' or ')' in arglist", token);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x6a1a
cmpl $0x18, %eax
jne 0x9a56
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x6a44
movq %rbx, %rdi
callq 0x8330
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0xa2f6
movq %rbx, %rdi
callq 0x6a44
movq %rax, %r12
cmpl $0x1d, %r12d
jne 0x9a91
movq %rbx, %rdi
callq 0x8330
movq %rax, 0x8(%rsp)
jmp 0x9a66
cmpl $0x18, %r12d
jne 0x9aa5
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rdx, %r13
movl $0x48, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0xddf8(%rip), %rsi      # 0x178b4
movq %rax, %rdi
movq %r12, %rdx
movq %r13, %rcx
callq 0xa9f6
leaq 0x16aa7(%rip), %rsi     # 0x20578
leaq 0x506(%rip), %rdx       # 0x9fde
movq %rbx, %rdi
callq 0x55d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/parser.cc
// Function: asbi::Parser::parse_map(ast::Node*)
ast::Map* Parser::parse_map(ast::Node* firstkey) {
	std::vector<std::pair<ast::Node*,ast::Node*>> values;
	values.push_back(std::make_pair(firstkey, parse_expr()));
	auto t = tokenizer.next();
	while (t.type == tok::Comma) {
		auto key = parse_expr();
		expect(tok::KeyValue);
		auto value = parse_expr();
		values.push_back(std::make_pair(key, value));
		t = tokenizer.next();
	}
	if (t.type != tok::RightSquareBracket)
		throw utils::parser_error("expected ',' or ')' while parsing map", t);

	return new ast::Map(std::move(values));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
callq 0x8330
movq %r14, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x9e26
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%rsp)
jmp 0x9e33
movq %rsp, %rdi
leaq 0x18(%rsp), %rdx
callq 0xa714
movq %rbx, %rdi
callq 0x6a44
movq %rax, %r12
movq %rdx, %r13
movq %rsp, %r14
leaq 0x18(%rsp), %r15
cmpl $0x1d, %r12d
jne 0x9eb0
movq %rbx, %rdi
callq 0x8330
movq %rax, %r12
movq %rbx, %rdi
movl $0xd, %esi
callq 0x810c
movq %rbx, %rdi
callq 0x8330
movq %r12, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x9e95
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%rsp)
jmp 0x9ea0
movq %r14, %rdi
movq %r15, %rdx
callq 0xa714
movq %rbx, %rdi
callq 0x6a44
movq %rax, %r12
movq %rdx, %r13
jmp 0x9e49
cmpl $0x1c, %r12d
jne 0x9f44
movl $0x20, %edi
callq 0x5380
movq %rax, %rbx
movq (%rsp), %rax
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x8(%rsi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x16be5(%rip), %rax     # 0x20ad8
addq $0x10, %rax
movq %rax, (%rbx)
movq %rbx, %rdi
addq $0x8, %rdi
callq 0xa1aa
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x9f1d
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x5390
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x9f33
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x5390
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x48, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0xd922(%rip), %rsi      # 0x1787a
movq %rax, %rdi
movq %r12, %rdx
movq %r13, %rcx
callq 0xa9f6
leaq 0x1660b(%rip), %rsi     # 0x20578
leaq 0x6a(%rip), %rdx        # 0x9fde
movq %rbx, %rdi
callq 0x55d0
movq %rax, %r14
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x9f96
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x5390
movl $0x20, %esi
movq %rbx, %rdi
callq 0x5390
jmp 0x9fbf
jmp 0x9fbc
jmp 0x9fbc
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
jmp 0x9fbf
jmp 0x9fbc
jmp 0x9fbc
jmp 0x9fbc
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x9fd5
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x5390
movq %r14, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/utils.cc
// Function: utils::tokenizer_error::tokenizer_error(char const*, int, char)
tokenizer_error::tokenizer_error(const char* msg, int line, char c):
		std::runtime_error(msg), line(line), c(c), what_message("TokenizerError: ") {
		what_message += msg;
		what_message += " (line: ";
		what_message += std::to_string(line);
		what_message += ", `";
		what_message += c;
		what_message += "`)";
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
callq 0x5620
leaq 0x15d03(%rip), %rax     # 0x20560
movq %rax, (%rbx)
movl %r15d, 0x10(%rbx)
movb %bpl, 0x14(%rbx)
leaq 0x18(%rbx), %r14
leaq 0x28(%rbx), %rax
movq %rax, (%rsp)
movq %rax, 0x18(%rbx)
leaq 0xd0c2(%rip), %rsi      # 0x17941
leaq 0xd0cb(%rip), %rdx      # 0x17951
movq %r14, %rdi
callq 0x6684
movq %r14, %rdi
movq %r12, %rsi
callq 0x5630
leaq 0xd0b2(%rip), %rsi      # 0x17952
movq %r14, %rdi
callq 0x5630
movl %r15d, %r12d
negl %r12d
cmovsl %r15d, %r12d
movl $0x1, %r13d
cmpl $0xa, %r12d
jb 0xa908
movl $0x4, %r13d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %r12d, %ecx
cmpl $0x63, %ecx
jbe 0xa8ff
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0xa905
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0xa908
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r13d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0xa8cc
addl $-0x3, %r13d
jmp 0xa908
addl $-0x2, %r13d
jmp 0xa908
decl %r13d
shrl $0x1f, %r15d
leal (%r15,%r13), %esi
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %rdi
movl $0x2d, %edx
callq 0x5410
movl %r15d, %edi
addq 0x8(%rsp), %rdi
movl %r13d, %esi
movl %r12d, %edx
callq 0x7bef
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x50e0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xa969
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
leaq 0xcfeb(%rip), %rsi      # 0x1795b
movq %r14, %rdi
callq 0x5630
movsbl %bpl, %esi
movq %r14, %rdi
callq 0x5300
leaq 0xcfd4(%rip), %rsi      # 0x1795f
movq %r14, %rdi
callq 0x5630
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xa9cd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
jmp 0xa9cd
jmp 0xa9ca
movq %rax, %r15
jmp 0xa9e5
movq %rax, %r15
movq (%r14), %rdi
cmpq (%rsp), %rdi
je 0xa9e5
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x53d0
movq %r15, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/utils.cc
// Function: utils::parser_error::parser_error(char const*, tok::Token)
parser_error::parser_error(const char* msg, tok::Token t):
		std::runtime_error(msg), token(t), node(nullptr), what_message("SyntaxError: ") {
		what_message += msg;
		what_message += " (near token: ";
		what_message += tok::to_string(t);
		what_message += ", line: ";
		what_message += std::to_string(t.line);
		what_message += ")";
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
callq 0x5620
leaq 0x15b94(%rip), %rax     # 0x205b0
movq %rax, (%rbx)
movq %r15, 0x10(%rbx)
movq %r12, 0x18(%rbx)
movq $0x0, 0x20(%rbx)
leaq 0x28(%rbx), %r14
leaq 0x38(%rbx), %rbp
movq %rbp, 0x28(%rbx)
leaq 0xcf20(%rip), %rsi      # 0x17962
leaq 0xcf26(%rip), %rdx      # 0x1796f
movq %r14, %rdi
callq 0x6684
movq %r14, %rdi
movq %r13, %rsi
callq 0x5630
leaq 0xcf0d(%rip), %rsi      # 0x17970
movq %r14, %rdi
callq 0x5630
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x6fe4
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x50e0
leaq 0x18(%rsp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0xaaa8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
leaq 0xced0(%rip), %rsi      # 0x1797f
movq %r14, %rdi
callq 0x5630
movq %r15, %r12
shrq $0x20, %r12
shrq $0x21, %r15
movl $0x1, %eax
cmpl $0x5, %r15d
jb 0xab12
movl $0x4, %eax
movl $0xd1b71759, %ecx       # imm = 0xD1B71759
movl %r12d, %edx
cmpl $0x63, %edx
jbe 0xab0b
cmpl $0x3e7, %edx            # imm = 0x3E7
jbe 0xab10
cmpl $0x2710, %edx           # imm = 0x2710
jb 0xab12
movl %edx, %esi
imulq %rcx, %rsi
shrq $0x2d, %rsi
addl $0x4, %eax
cmpl $0x1869f, %edx          # imm = 0x1869F
movl %esi, %edx
ja 0xaada
addl $-0x3, %eax
jmp 0xab12
addl $-0x2, %eax
jmp 0xab12
decl %eax
movl %eax, %esi
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
xorl %edx, %edx
callq 0x5410
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
movl %r12d, %edx
callq 0x7bef
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x50e0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xab5d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
leaq 0xc927(%rip), %rsi      # 0x1748b
movq %r14, %rdi
callq 0x5630
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
jne 0xab9d
jmp 0xabb6
jmp 0xabb3
movq %rax, %r15
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xabb6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
jmp 0xabb6
jmp 0xabb3
movq %rax, %r15
jmp 0xabca
movq %rax, %r15
movq (%r14), %rdi
cmpq %rbp, %rdi
je 0xabca
movq (%rbp), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x53d0
movq %r15, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/utils.cc
// Function: utils::parser_error::parser_error(char const*, ast::Node*)
parser_error::parser_error(const char* msg, ast::Node* node):
		std::runtime_error(msg), token(tok::Token(tok::EOFTok, 0)), node(node), what_message("SyntaxError: ") {
		what_message += msg;
		/*what_message += " (near ast node: ";
		node->to_string(what_message);
		what_message += ")";*/
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x5620
leaq 0x159b9(%rip), %rax     # 0x205b0
movq %rax, (%rbx)
movq $0x25, 0x10(%rbx)
movl $0x0, 0x18(%rbx)
movq %r15, 0x20(%rbx)
leaq 0x28(%rbx), %r15
leaq 0x38(%rbx), %r12
movq %r12, 0x28(%rbx)
leaq 0xcd42(%rip), %rsi      # 0x17962
leaq 0xcd48(%rip), %rdx      # 0x1796f
movq %r15, %rdi
callq 0x6684
movq %r15, %rdi
movq %r14, %rsi
callq 0x5630
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%r15), %rdi
cmpq %r12, %rdi
je 0xac62
movq (%r12), %rsi
incq %rsi
callq 0x5390
jmp 0xac62
movq %rax, %r14
movq %rbx, %rdi
callq 0x53d0
movq %r14, %rdi
callq 0x55e0