LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RGBD/RGBDUtil.cpp
// Function: gaps::RGBDCreateNormalChannels(gaps::R2Grid const&, gaps::R2Grid const&, gaps::R2Grid const&, gaps::R2Grid const&, gaps::R2Grid const&, gaps::R2Grid&, gaps::R2Grid&, gaps::R2Grid&, gaps::R2Grid&, gaps::R3Point const&, gaps::R3Vector const&, gaps::R3Vector const&, double, int, int)
int RGBDCreateNormalChannels(const R2Grid& input_depth_image, 
  const R2Grid& input_px_image, const R2Grid& input_py_image, const R2Grid& input_pz_image,
  const R2Grid& input_boundary_image,
  R2Grid& output_nx_image, R2Grid& output_ny_image, R2Grid& output_nz_image, R2Grid& output_radius_image,
  const R3Point& viewpoint, const R3Vector& towards, const R3Vector& up,
  RNLength neighborhood_world_radius, int neighborhood_pixel_radius, RNBoolean neighborhood_search)
{
  // Create normal images
  R2Grid tx_image, ty_image, tz_image, r2_image;
  return RGBDCreateTangentChannels(input_depth_image, input_px_image, input_py_image, input_pz_image, input_boundary_image,
    output_nx_image, output_ny_image, output_nz_image, tx_image, ty_image, tz_image, output_radius_image, r2_image,
    viewpoint, towards, up, neighborhood_world_radius, neighborhood_pixel_radius, neighborhood_search);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3c8, %rsp            # imm = 0x3C8
movsd %xmm0, 0x80(%rsp)
movq %r9, 0x68(%rsp)
movq %r8, %r13
movq %rcx, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rsi, %r12
movq %rdi, %rbp
leaq 0x88(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5f630
leaq 0x2f8(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5f630
leaq 0x228(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5f630
leaq 0x158(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5f630
movl 0x438(%rsp), %eax
movl 0x430(%rsp), %ecx
movq 0x418(%rsp), %rdx
movq 0x410(%rsp), %rsi
movq 0x408(%rsp), %rdi
movq 0x400(%rsp), %r8
movl %eax, 0x58(%rsp)
movl %ecx, 0x50(%rsp)
movq %rdx, 0x38(%rsp)
movq %r15, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %r14, 0x20(%rsp)
movq %rbx, 0x18(%rsp)
leaq 0x88(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq %r8, (%rsp)
movq %r13, %r8
movq 0x68(%rsp), %r9
movq %rbp, %rdi
movq %r12, %rsi
movq 0x70(%rsp), %rdx
movq 0x78(%rsp), %rcx
movsd 0x80(%rsp), %xmm0
callq 0x21f65
leaq 0x158(%rsp), %rdi
callq 0x60264
leaq 0x228(%rsp), %rdi
callq 0x60264
leaq 0x2f8(%rsp), %rdi
callq 0x60264
leaq 0x88(%rsp), %rdi
callq 0x60264
movl $0x1, %eax
addq $0x3c8, %rsp            # imm = 0x3C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x158(%rsp), %rdi
callq 0x60264
jmp 0x219a0
movq %rax, %rbx
leaq 0x228(%rsp), %rdi
callq 0x60264
jmp 0x219b2
movq %rax, %rbx
leaq 0x2f8(%rsp), %rdi
callq 0x60264
jmp 0x219c4
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x60264
movq %rbx, %rdi
callq 0x11a60
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::parse(char const*, char const*, Json::Value&, bool)
bool Reader::parse(const char* beginDoc,
                   const char* endDoc,
                   Value& root,
                   bool collectComments) {
  if (!features_.allowComments_) {
    collectComments = false;
  }

  begin_ = beginDoc;
  end_ = endDoc;
  collectComments_ = collectComments;
  current_ = begin_;
  lastValueEnd_ = 0;
  lastValue_ = 0;
  commentsBefore_ = "";
  errors_.clear();
  while (!nodes_.empty())
    nodes_.pop();
  nodes_.push(&root);

  stackDepth_g = 0;  // Yes, this is bad coding, but options are limited.
  bool successful = readValue();
  Token token;
  skipCommentTokens(token);
  if (collectComments_ && !commentsBefore_.empty())
    root.setComment(commentsBefore_, commentAfter);
  if (features_.strictRoot_) {
    if (!root.isArray() && !root.isObject()) {
      // Set error location to start of doc, ideally should be first token found
      // in doc
      token.type_ = tokenError;
      token.start_ = beginDoc;
      token.end_ = endDoc;
      addError(
          "A valid JSON document must be either an array or an object value.",
          token);
      return false;
    }
  }
  return successful;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
andb 0x108(%rdi), %r8b
movq %rsi, 0xc0(%rdi)
movq %rdx, 0xc8(%rdi)
movb %r8b, 0x10c(%rdi)
movq %rsi, 0xd0(%rdi)
leaq 0xe8(%rdi), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0xd8(%rdi)
movq 0xf0(%rdi), %rdx
leaq 0x44338(%rip), %rcx     # 0xbc634
movq %r13, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x11910
leaq 0x50(%rbx), %rdi
callq 0x87664
movq 0x30(%rbx), %rax
cmpq 0x10(%rbx), %rax
je 0x78326
movq %rbx, %rdi
callq 0x88d1c
jmp 0x78312
movq %rsp, %rsi
movq %r12, (%rsi)
movq %rbx, %rdi
callq 0x88d68
movl $0x0, 0x8f27e(%rip)     # 0x1075bc
movq %rbx, %rdi
callq 0x784de
movl %eax, %ebp
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x788ee
cmpb $0x1, 0x10c(%rbx)
jne 0x7837b
movq 0xf0(%rbx), %rdx
testq %rdx, %rdx
je 0x7837b
movq (%r13), %rsi
movq %r12, %rdi
movl $0x2, %ecx
callq 0x82a6e
cmpb $0x1, 0x109(%rbx)
jne 0x783f6
movzwl 0x8(%r12), %eax
andl $0xfe, %eax
cmpw $0x6, %ax
je 0x783f6
leaq 0x20(%rsp), %r12
movl $0xd, (%r12)
movq %r15, 0x8(%r12)
movq %r14, 0x10(%r12)
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x46cfc(%rip), %rsi     # 0xbf0b8
leaq 0x46d36(%rip), %rdx     # 0xbf0f9
movq %rsp, %r14
movq %r14, %rdi
callq 0x1a88c
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x7894e
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x783f4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x115c0
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x78420
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x115c0
movq %rbx, %rdi
callq 0x11a60
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::parse(std::istream&, Json::Value&, bool)
bool Reader::parse(std::istream& sin, Value& root, bool collectComments) {
  // std::istream_iterator<char> begin(sin);
  // std::istream_iterator<char> end;
  // Those would allow streamed input from a file, if parse() were a
  // template function.

  // Since std::string is reference-counted, this at least does not
  // create an extra copy.
  std::string doc;
  std::getline(sin, doc, (char)EOF);
  return parse(doc, root, collectComments);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x11af0
leaq 0xa0(%r14), %rdi
leaq 0x8(%rsp), %rsi
callq 0x11300
movq 0xa0(%r14), %rsi
movq 0xa8(%r14), %rdx
addq %rsi, %rdx
movzbl %bpl, %r8d
movq %r14, %rdi
movq %rbx, %rcx
callq 0x782a0
movl %eax, %ebx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x784ae
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x115c0
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x784d5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x115c0
movq %rbx, %rdi
callq 0x11a60
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::skipCommentTokens(Json::Reader::Token&)
void Reader::skipCommentTokens(Token& token) {
  if (features_.allowComments_) {
    do {
      readToken(token);
    } while (token.type_ == tokenComment);
  } else {
    readToken(token);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x108(%rdi)
jne 0x78919
movq %r14, %rdi
movq %rbx, %rsi
callq 0x793c0
cmpl $0xc, (%rbx)
je 0x78901
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x793c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::addError(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Json::Reader::Token&, char const*)
bool
Reader::addError(const std::string& message, Token& token, Location extra) {
  ErrorInfo info;
  info.token_ = token;
  info.message_ = message;
  info.extra_ = extra;
  errors_.push_back(info);
  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rcx, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movups (%rdx), %xmm0
movaps %xmm0, -0x28(%r15)
movq 0x10(%rdx), %rax
movq %rax, -0x18(%r15)
callq 0x11300
movq %rsp, %rsi
movq %r14, 0x38(%rsi)
addq $0x50, %rbx
movq %rbx, %rdi
callq 0x876ca
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x789b6
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x115c0
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x789dc
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x115c0
movq %rbx, %rdi
callq 0x11a60
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::decodeNumber(Json::Reader::Token&)
bool Reader::decodeNumber(Token& token) {
  Value decoded;
  if (!decodeNumber(token, decoded))
    return false;
  currentValue().swapPayload(decoded);
  currentValue().setOffsetStart(token.start_ - begin_);
  currentValue().setOffsetLimit(token.end_ - begin_);
  return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
movw $0x0, 0x8(%rdx)
pxor %xmm0, %xmm0
movdqu %xmm0, 0x10(%rdx)
xorl %eax, %eax
movq %rax, 0x20(%rdx)
movq %rax, (%rdx)
callq 0x79d64
movl %eax, %ebp
testb %al, %al
je 0x79218
movq 0x30(%rbx), %rax
cmpq 0x38(%rbx), %rax
jne 0x7919b
movq 0x48(%rbx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %rax
movzwl 0x8(%rax), %ecx
movzwl 0x10(%rsp), %edx
movl $0xfe00, %esi           # imm = 0xFE00
movl %ecx, %edi
andl %esi, %edi
andl %edx, %esi
movq (%rax), %r8
movq 0x8(%rsp), %r9
movq %r9, (%rax)
movq %r8, 0x8(%rsp)
movl $0x1ff, %r8d            # imm = 0x1FF
andl %r8d, %edx
orl %edi, %edx
movw %dx, 0x8(%rax)
andl %r8d, %ecx
orl %esi, %ecx
movw %cx, 0x10(%rsp)
movq 0x30(%rbx), %rax
cmpq 0x38(%rbx), %rax
je 0x791ec
addq $-0x8, %rax
jmp 0x791f9
movq 0x48(%rbx), %rcx
movl $0x1f8, %eax            # imm = 0x1F8
addq -0x8(%rcx), %rax
movq (%rax), %rax
movdqu 0x8(%r14), %xmm0
movq 0xc0(%rbx), %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
psubq %xmm1, %xmm0
movdqu %xmm0, 0x18(%rax)
leaq 0x8(%rsp), %rdi
callq 0x80736
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x80736
movq %rbx, %rdi
callq 0x11a60
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::decodeString(Json::Reader::Token&)
bool Reader::decodeString(Token& token) {
  std::string decoded_string;
  if (!decodeString(token, decoded_string))
    return false;
  Value decoded(decoded_string);
  currentValue().swapPayload(decoded);
  currentValue().setOffsetStart(token.start_ - begin_);
  currentValue().setOffsetLimit(token.end_ - begin_);
  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq %rsp, %rdx
callq 0x79a5a
movl %eax, %ebx
testb %al, %al
je 0x79329
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rsp)
movq $0x0, 0x40(%rsp)
movq (%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0x8038f
movq 0x30(%r14), %rcx
cmpq 0x38(%r14), %rcx
jne 0x792b2
movq 0x48(%r14), %rdx
movl $0x200, %ecx            # imm = 0x200
addq -0x8(%rdx), %rcx
movq -0x8(%rcx), %rcx
movzwl 0x8(%rcx), %edx
movl %edx, %esi
andl $0xfe00, %esi           # imm = 0xFE00
movq (%rcx), %rdi
movq %rax, (%rcx)
movq %rdi, 0x20(%rsp)
orl $0x104, %esi            # imm = 0x104
movw %si, 0x8(%rcx)
andl $0x1ff, %edx            # imm = 0x1FF
movw %dx, 0x28(%rsp)
movq 0x30(%r14), %rax
cmpq 0x38(%r14), %rax
je 0x792f2
addq $-0x8, %rax
jmp 0x792ff
movq 0x48(%r14), %rcx
movl $0x1f8, %eax            # imm = 0x1F8
addq -0x8(%rcx), %rax
movq (%rax), %rax
movdqu 0x8(%r15), %xmm0
movq 0xc0(%r14), %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
psubq %xmm1, %xmm0
movdqu %xmm0, 0x18(%rax)
leaq 0x20(%rsp), %rdi
callq 0x80736
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x7933f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x115c0
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x7934f
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x79368
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x115c0
movq %rbx, %rdi
callq 0x11a60
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::skipSpaces()
void Reader::skipSpaces() {
  while (current_ != end_) {
    Char c = *current_;
    if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
      ++current_;
    else
      break;
  }
}

// Assembly:
movq 0xc8(%rdi), %rax
movq 0xd0(%rdi), %rcx
cmpq %rax, %rcx
je 0x7961d
movabsq $0x100002600, %rdx      # imm = 0x100002600
movzbl (%rcx), %esi
cmpq $0x20, %rsi
ja 0x7961d
btq %rsi, %rdx
jae 0x7961d
incq %rcx
movq %rcx, 0xd0(%rdi)
cmpq %rax, %rcx
jne 0x795ff
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::readString()
bool Reader::readString() {
  Char c = 0;
  while (current_ != end_) {
    c = getNextChar();
    if (c == '\\')
      getNextChar();
    else if (c == '"')
      break;
  }
  return c == '"';
}

// Assembly:
movq 0xc8(%rdi), %rax
movq 0xd0(%rdi), %rdx
cmpq %rax, %rdx
je 0x7968f
leaq 0x1(%rdx), %rsi
movq %rsi, 0xd0(%rdi)
movzbl (%rdx), %ecx
cmpl $0x5c, %ecx
je 0x7966d
cmpl $0x22, %ecx
jne 0x79680
jmp 0x79688
cmpq %rax, %rsi
je 0x79680
addq $0x2, %rdx
movq %rdx, 0xd0(%rdi)
movq %rdx, %rsi
movq %rsi, %rdx
cmpq %rax, %rsi
jne 0x79653
cmpb $0x22, %cl
sete %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::readComment()
bool Reader::readComment() {
  Location commentBegin = current_ - 1;
  Char c = getNextChar();
  bool successful = false;
  if (c == '*')
    successful = readCStyleComment();
  else if (c == '/')
    successful = readCppStyleComment();
  if (!successful)
    return false;

  if (collectComments_) {
    CommentPlacement placement = commentBefore;
    if (lastValueEnd_ && !containsNewLine(lastValueEnd_, commentBegin)) {
      if (c != '*' || !containsNewLine(commentBegin, current_))
        placement = commentAfterOnSameLine;
    }

    addComment(commentBegin, current_, placement);
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0xd0(%rdi), %rbx
cmpq 0xc8(%rdi), %rbx
je 0x7977c
movq %rdi, %r14
leaq 0x1(%rbx), %rax
movq %rax, 0xd0(%rdi)
movzbl (%rbx), %r15d
cmpl $0x2a, %r15d
je 0x796d9
cmpl $0x2f, %r15d
jne 0x7977c
movq %r14, %rdi
callq 0x798dc
jmp 0x796e9
movq %r14, %rdi
callq 0x7989a
testb %al, %al
je 0x7977c
movb $0x1, %bpl
cmpb $0x1, 0x10c(%r14)
jne 0x7977e
decq %rbx
movq 0xd8(%r14), %rax
xorl %ecx, %ecx
testq %rax, %rax
je 0x79768
cmpq %rbx, %rax
jae 0x7972f
movb $0x1, %dl
movzbl (%rax), %esi
cmpl $0xa, %esi
je 0x7972a
cmpl $0xd, %esi
je 0x7972a
incq %rax
cmpq %rbx, %rax
setb %dl
jne 0x79712
testb $0x1, %dl
jne 0x79768
cmpb $0x2a, %r15b
jne 0x79763
movq 0xd0(%r14), %rax
cmpq %rax, %rbx
jae 0x79763
movb $0x1, %dl
movq %rbx, %rsi
movzbl (%rsi), %edi
cmpl $0xa, %edi
je 0x7975e
cmpl $0xd, %edi
je 0x7975e
incq %rsi
cmpq %rax, %rsi
setb %dl
jne 0x79746
testb $0x1, %dl
jne 0x79768
movl $0x1, %ecx
movq 0xd0(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x79922
jmp 0x7977e
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::readNumber()
void Reader::readNumber() {
  const char *p = current_;
  char c = '0'; // stopgap for already consumed character
  // integral part
  while (c >= '0' && c <= '9')
    c = (current_ = p) < end_ ? *p++ : 0;
  // fractional part
  if (c == '.') {
    c = (current_ = p) < end_ ? *p++ : 0;
    while (c >= '0' && c <= '9')
      c = (current_ = p) < end_ ? *p++ : 0;
  }
  // exponential part
  if (c == 'e' || c == 'E') {
    c = (current_ = p) < end_ ? *p++ : 0;
    if (c == '+' || c == '-')
      c = (current_ = p) < end_ ? *p++ : 0;
    while (c >= '0' && c <= '9')
      c = (current_ = p) < end_ ? *p++ : 0;
  }
}

// Assembly:
movq 0xc8(%rdi), %rax
movq 0xd0(%rdi), %rcx
movq %rcx, 0xd0(%rdi)
cmpq %rax, %rcx
jae 0x79854
movb (%rcx), %dl
incq %rcx
leal -0x30(%rdx), %esi
cmpb $0xa, %sil
jb 0x7979a
cmpb $0x2e, %dl
jne 0x797f5
movq %rcx, 0xd0(%rdi)
cmpq %rax, %rcx
jae 0x79854
movb (%rcx), %dl
incq %rcx
leal -0x30(%rdx), %esi
cmpb $0x9, %sil
ja 0x797f5
movq %rcx, 0xd0(%rdi)
cmpq %rax, %rcx
jae 0x79854
movb (%rcx), %dl
incq %rcx
leal -0x30(%rdx), %esi
cmpb $0xa, %sil
jb 0x797db
andb $-0x21, %dl
cmpb $0x45, %dl
jne 0x79854
movq %rcx, 0xd0(%rdi)
cmpq %rax, %rcx
jae 0x79854
leaq 0x1(%rcx), %rdx
movzbl (%rcx), %esi
cmpl $0x2d, %esi
je 0x7981a
cmpl $0x2b, %esi
jne 0x79831
movq %rdx, 0xd0(%rdi)
cmpq %rax, %rdx
jae 0x79854
movb 0x1(%rcx), %sil
addq $0x2, %rcx
movq %rcx, %rdx
addb $-0x30, %sil
cmpb $0x9, %sil
ja 0x79854
movq %rdx, 0xd0(%rdi)
cmpq %rax, %rdx
jae 0x79854
movb (%rdx), %cl
incq %rdx
addb $-0x30, %cl
cmpb $0xa, %cl
jb 0x7983b
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::match(char const*, int)
bool Reader::match(Location pattern, int patternLength) {
  if (end_ - current_ < patternLength)
    return false;
  int index = patternLength;
  while (index--)
    if (current_[index] != pattern[index])
      return false;
  current_ += patternLength;
  return true;
}

// Assembly:
movq 0xc8(%rdi), %r8
movq 0xd0(%rdi), %rax
subq %rax, %r8
movslq %edx, %rcx
cmpq %rcx, %r8
jl 0x7988a
movq %rcx, %r8
movq %rcx, %rdx
subq $0x1, %rdx
jb 0x7988d
movb -0x1(%rax,%r8), %r9b
cmpb -0x1(%rsi,%r8), %r9b
movq %rdx, %r8
je 0x79875
xorl %eax, %eax
retq
addq %rcx, %rax
movq %rax, 0xd0(%rdi)
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::readCStyleComment()
bool Reader::readCStyleComment() {
  while (current_ != end_) {
    Char c = getNextChar();
    if (c == '*' && *current_ == '/')
      break;
  }
  return getNextChar() == '/';
}

// Assembly:
movq 0xc8(%rdi), %rcx
movq 0xd0(%rdi), %rax
cmpq %rcx, %rax
je 0x798c2
incq %rax
movq %rax, 0xd0(%rdi)
cmpb $0x2a, -0x1(%rax)
jne 0x798a8
cmpb $0x2f, (%rax)
jne 0x798a8
cmpq %rcx, %rax
je 0x798d9
leaq 0x1(%rax), %rcx
movq %rcx, 0xd0(%rdi)
cmpb $0x2f, (%rax)
sete %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::readCppStyleComment()
bool Reader::readCppStyleComment() {
  while (current_ != end_) {
    Char c = getNextChar();
    if (c == '\n')
      break;
    if (c == '\r') {
      // Consume DOS EOL. It will be normalized in addComment.
      if (current_ != end_ && *current_ == '\n')
        getNextChar();
      // Break on Moc OS 9 EOL.
      break;
    }
  }
  return true;
}

// Assembly:
movq 0xc8(%rdi), %rcx
movq 0xd0(%rdi), %rdx
cmpq %rcx, %rdx
je 0x7991e
leaq 0x1(%rdx), %rax
movq %rax, 0xd0(%rdi)
movzbl (%rdx), %esi
cmpl $0xa, %esi
je 0x7991e
movq %rax, %rdx
cmpl $0xd, %esi
jne 0x798ea
cmpq %rcx, %rax
je 0x7991e
cmpb $0xa, (%rax)
jne 0x7991e
incq %rax
movq %rax, 0xd0(%rdi)
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::addComment(char const*, char const*, Json::CommentPlacement)
void
Reader::addComment(Location begin, Location end, CommentPlacement placement) {
  assert(collectComments_);
  const std::string& normalized = normalizeEOL(begin, end);
  if (placement == commentAfterOnSameLine) {
    assert(lastValue_ != 0);
    lastValue_->setComment(normalized, placement);
  } else {
    commentsBefore_ += normalized;
  }
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x799ba
cmpl $0x1, %ebp
jne 0x79959
movq 0xe0(%rbx), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl $0x1, %ecx
callq 0x82a6e
jmp 0x79972
addq $0xe8, %rbx
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x111e0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7998d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x115c0
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x799b2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x115c0
movq %rbx, %rdi
callq 0x11a60
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::normalizeEOL[abi:cxx11](char const*, char const*)
static std::string normalizeEOL(Reader::Location begin, Reader::Location end) {
  std::string normalized;
  normalized.reserve(static_cast<size_t>(end - begin));
  Reader::Location current = begin;
  while (current != end) {
    char c = *current++;
    if (c == '\r') {
      if (current != end && *current == '\n')
         // convert dos EOL
         ++current;
      // convert Mac EOL
      normalized += '\n';
    } else {
      normalized += c;
    }
  }
  return normalized;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rdx, %rsi
subq %r15, %rsi
callq 0x11950
cmpq %r14, %r15
je 0x79a2f
leaq 0x1(%r15), %r13
movb (%r15), %al
cmpb $0xd, %al
jne 0x79a1c
cmpq %r14, %r13
je 0x79a0d
cmpb $0xa, 0x1(%r15)
jne 0x79a0d
addq $0x2, %r15
movq %r15, %r13
movq %rbx, %rdi
movl $0xa, %esi
callq 0x114e0
jmp 0x79a27
movsbl %al, %esi
movq %rbx, %rdi
callq 0x114e0
movq %r13, %r15
cmpq %r14, %r13
jne 0x799ef
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x79a3b
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x79a52
movq (%r12), %rsi
incq %rsi
callq 0x115c0
movq %r14, %rdi
callq 0x11a60
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::recoverFromError(Json::Reader::TokenType)
bool Reader::recoverFromError(TokenType skipUntilToken) {
  size_t const errorCount = errors_.size();
  Token skip;
  for (;;) {
    if (!readToken(skip))
      errors_.resize(errorCount); // discard errors caused by recovery
    if (skip.type_ == skipUntilToken || skip.type_ == tokenEndOfStream)
      break;
  }
  errors_.resize(errorCount);
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x98(%rdi), %r13
movq 0x78(%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0x80(%rdi), %r12
movq 0x88(%rdi), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rdi), %rax
movq %rax, 0x18(%rsp)
movq 0x70(%rdi), %r14
leaq 0x20(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x793c0
movl 0x20(%rsp), %eax
cmpl %ebp, %eax
je 0x79d11
testl %eax, %eax
jne 0x79cfa
subq 0x8(%rsp), %r12
sarq $0x6, %r12
movq %r13, %rax
subq 0x10(%rsp), %rax
negq %r13
movl $0x0, %ecx
sbbq %rcx, %rcx
leaq (%rax,%rcx,8), %rax
andq $-0x8, %rax
subq 0x18(%rsp), %r14
sarq $0x6, %r14
addq %r12, %r14
addq %rax, %r14
addq $0x50, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x87736
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::asString[abi:cxx11]() const
std::string Value::asString() const {
  switch (type_) {
  case nullValue:
    return "";
  case stringValue:
  {
    if (value_.string_ == 0) return "";
    unsigned this_len;
    char const* this_str;
    decodePrefixedString(this->allocated_, this->value_.string_, &this_len, &this_str);
    return std::string(this_str, this_len);
  }
  case booleanValue:
    return value_.bool_ ? "true" : "false";
  case intValue:
    return valueToString(value_.int_);
  case uintValue:
    return valueToString(value_.uint_);
  case realValue:
    return valueToString(value_.real_);
  default:
    JSON_FAIL_MESSAGE("Type is not convertible to string");
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movzwl 0x8(%rsi), %eax
cmpb $0x5, %al
ja 0x79fdf
movq %rdi, %rbx
movzbl %al, %ecx
leaq 0x44cfd(%rip), %rdx     # 0xbec1c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq (%rsi), %rsi
movq %rbx, %rdi
callq 0x80b6c
jmp 0x79fd1
movq (%rsi), %r14
testq %r14, %r14
je 0x79f50
btl $0x8, %eax
jb 0x79fb3
movq %r14, %rdi
callq 0x11260
jmp 0x79fba
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x426d6(%rip), %rdx     # 0xbc634
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x79fcc
movq (%rsi), %rsi
movq %rbx, %rdi
callq 0x80c69
jmp 0x79fd1
movsd (%rsi), %xmm0
movq %rbx, %rdi
xorl %esi, %esi
movl $0x11, %edx
callq 0x832ea
jmp 0x79fd1
movzbl (%rsi), %edx
leaq 0x455b0(%rip), %rax     # 0xbf542
leaq 0x455ae(%rip), %rsi     # 0xbf547
testq %rdx, %rdx
cmovneq %rax, %rsi
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
xorq $0x5, %rdx
addq %rsi, %rdx
movq %rbx, %rdi
jmp 0x79fcc
movl (%r14), %eax
addq $0x4, %r14
movl %eax, %edx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
addq %r14, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a88c
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x117f0
leaq 0x4555a(%rip), %rsi     # 0xbf54d
movl $0x21, %edx
movq %rbx, %rdi
callq 0x116c0
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x11980
movq %rsp, %rdi
callq 0x7fe09
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7a03a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x115c0
jmp 0x7a03a
jmp 0x7a037
movq %rax, %rbx
movq 0x89f5f(%rip), %rsi     # 0x103fa0
leaq 0x20(%rsp), %rdi
callq 0x112f0
leaq 0x90(%rsp), %rdi
callq 0x111f0
movq %rbx, %rdi
callq 0x11a60
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::operator[](int)
Value& Value::operator[](int index) {
  JSON_ASSERT_MESSAGE(
      index >= 0,
      "in Json::Value::operator[](int index): index cannot be negative");
  return (*this)[ArrayIndex(index)];
}

// Assembly:
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
testl %esi, %esi
js 0x7a0af
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
jmp 0x819ea
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x117f0
leaq 0x45751(%rip), %rsi     # 0xbf814
movl $0x3f, %edx
movq %rbx, %rdi
callq 0x116c0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11980
leaq 0x8(%rsp), %rdi
callq 0x7fe09
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7a10e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x115c0
jmp 0x7a10e
jmp 0x7a10b
movq %rax, %rbx
movq 0x89e8b(%rip), %rsi     # 0x103fa0
leaq 0x28(%rsp), %rdi
callq 0x112f0
leaq 0x98(%rsp), %rdi
callq 0x111f0
movq %rbx, %rdi
callq 0x11a60
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::decodeDouble(Json::Reader::Token&)
bool Reader::decodeDouble(Token& token) {
  Value decoded;
  if (!decodeDouble(token, decoded))
    return false;
  currentValue().swapPayload(decoded);
  currentValue().setOffsetStart(token.start_ - begin_);
  currentValue().setOffsetLimit(token.end_ - begin_);
  return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
movw $0x0, 0x8(%rdx)
pxor %xmm0, %xmm0
movdqu %xmm0, 0x10(%rdx)
xorl %eax, %eax
movq %rax, 0x20(%rdx)
movq %rax, (%rdx)
callq 0x7a134
movl %eax, %ebp
testb %al, %al
je 0x7a564
movq 0x30(%rbx), %rax
cmpq 0x38(%rbx), %rax
jne 0x7a4e7
movq 0x48(%rbx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %rax
movzwl 0x8(%rax), %ecx
movzwl 0x10(%rsp), %edx
movl $0xfe00, %esi           # imm = 0xFE00
movl %ecx, %edi
andl %esi, %edi
andl %edx, %esi
movq (%rax), %r8
movq 0x8(%rsp), %r9
movq %r9, (%rax)
movq %r8, 0x8(%rsp)
movl $0x1ff, %r8d            # imm = 0x1FF
andl %r8d, %edx
orl %edi, %edx
movw %dx, 0x8(%rax)
andl %r8d, %ecx
orl %esi, %ecx
movw %cx, 0x10(%rsp)
movq 0x30(%rbx), %rax
cmpq 0x38(%rbx), %rax
je 0x7a538
addq $-0x8, %rax
jmp 0x7a545
movq 0x48(%rbx), %rcx
movl $0x1f8, %eax            # imm = 0x1F8
addq -0x8(%rcx), %rax
movq (%rax), %rax
movdqu 0x8(%r14), %xmm0
movq 0xc0(%rbx), %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
psubq %xmm1, %xmm0
movdqu %xmm0, 0x18(%rax)
leaq 0x8(%rsp), %rdi
callq 0x80736
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x80736
movq %rbx, %rdi
callq 0x11a60
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::decodeUnicodeCodePoint(Json::Reader::Token&, char const*&, char const*, unsigned int&)
bool Reader::decodeUnicodeCodePoint(Token& token,
                                    Location& current,
                                    Location end,
                                    unsigned int& unicode) {

  if (!decodeUnicodeEscapeSequence(token, current, end, unicode))
    return false;
  if (unicode >= 0xD800 && unicode <= 0xDBFF) {
    // surrogate pairs
    if (end - current < 6)
      return addError(
          "additional six characters expected to parse unicode surrogate pair.",
          token,
          current);
    unsigned int surrogatePair;
    if (*(current++) == '\\' && *(current++) == 'u') {
      if (decodeUnicodeEscapeSequence(token, current, end, surrogatePair)) {
        unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
      } else
        return false;
    } else
      return addError("expecting another \\u token to begin the second half of "
                      "a unicode surrogate pair",
                      token,
                      current);
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x7a810
testb %al, %al
je 0x7a6b9
movl $0xfffffc00, %eax       # imm = 0xFFFFFC00
andl (%r12), %eax
movb $0x1, %bpl
cmpl $0xd800, %eax           # imm = 0xD800
jne 0x7a6bb
movq (%r15), %rax
movq %r13, %rcx
subq %rax, %rcx
cmpq $0x5, %rcx
jg 0x7a618
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x44c47(%rip), %rsi     # 0xbf236
leaq 0x44c83(%rip), %rdx     # 0xbf279
leaq 0x8(%rsp), %rdi
callq 0x1a88c
movq (%r15), %rcx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x7894e
jmp 0x7a6a2
leaq 0x1(%rax), %rcx
movq %rcx, (%r15)
cmpb $0x5c, (%rax)
jne 0x7a66d
leaq 0x2(%rax), %rcx
movq %rcx, (%r15)
cmpb $0x75, 0x1(%rax)
jne 0x7a66d
leaq 0x4(%rsp), %r8
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0x7a810
testb %al, %al
je 0x7a6b9
movl (%r12), %eax
shll $0xa, %eax
andl $0xffc00, %eax          # imm = 0xFFC00
movl $0x3ff, %ecx            # imm = 0x3FF
andl 0x4(%rsp), %ecx
addl %ecx, %eax
addl $0x10000, %eax          # imm = 0x10000
movl %eax, (%r12)
jmp 0x7a6bb
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x44bfc(%rip), %rsi     # 0xbf27a
leaq 0x44c44(%rip), %rdx     # 0xbf2c9
leaq 0x8(%rsp), %rdi
callq 0x1a88c
movq (%r15), %rcx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x7894e
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7a6b9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x115c0
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7a6d0
jmp 0x7a6ec
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7a6ef
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x115c0
jmp 0x7a6ef
movq %rax, %rbx
movq %rbx, %rdi
callq 0x11a60
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::codePointToUTF8[abi:cxx11](unsigned int)
static inline std::string codePointToUTF8(unsigned int cp) {
  std::string result;

  // based on description from http://en.wikipedia.org/wiki/UTF-8

  if (cp <= 0x7f) {
    result.resize(1);
    result[0] = static_cast<char>(cp);
  } else if (cp <= 0x7FF) {
    result.resize(2);
    result[1] = static_cast<char>(0x80 | (0x3f & cp));
    result[0] = static_cast<char>(0xC0 | (0x1f & (cp >> 6)));
  } else if (cp <= 0xFFFF) {
    result.resize(3);
    result[2] = static_cast<char>(0x80 | (0x3f & cp));
    result[1] = static_cast<char>(0x80 | (0x3f & (cp >> 6)));
    result[0] = static_cast<char>(0xE0 | (0xf & (cp >> 12)));
  } else if (cp <= 0x10FFFF) {
    result.resize(4);
    result[3] = static_cast<char>(0x80 | (0x3f & cp));
    result[2] = static_cast<char>(0x80 | (0x3f & (cp >> 6)));
    result[1] = static_cast<char>(0x80 | (0x3f & (cp >> 12)));
    result[0] = static_cast<char>(0xF0 | (0x7 & (cp >> 18)));
  }

  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpl $0x7f, %esi
ja 0x7a72f
movl $0x1, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x111d0
jmp 0x7a7e1
cmpl $0x7ff, %ebp            # imm = 0x7FF
ja 0x7a75e
movl $0x2, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x111d0
movl %ebp, %eax
andb $0x3f, %al
orb $-0x80, %al
movq (%rbx), %rcx
movb %al, 0x1(%rcx)
shrl $0x6, %ebp
orb $-0x40, %bpl
jmp 0x7a7e1
cmpl $0xffff, %ebp           # imm = 0xFFFF
ja 0x7a799
movl $0x3, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x111d0
movl %ebp, %eax
andb $0x3f, %al
orb $-0x80, %al
movq (%rbx), %rcx
movb %al, 0x2(%rcx)
movl %ebp, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movq (%rbx), %rcx
movb %al, 0x1(%rcx)
shrl $0xc, %ebp
orb $-0x20, %bpl
jmp 0x7a7e1
cmpl $0x10ffff, %ebp         # imm = 0x10FFFF
ja 0x7a7e7
movl $0x4, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x111d0
movl %ebp, %eax
andb $0x3f, %al
orb $-0x80, %al
movq (%rbx), %rcx
movb %al, 0x3(%rcx)
movl %ebp, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movq (%rbx), %rcx
movb %al, 0x2(%rcx)
movl %ebp, %eax
shrl $0xc, %eax
andb $0x3f, %al
orb $-0x80, %al
movq (%rbx), %rcx
movb %al, 0x1(%rcx)
shrl $0x12, %ebp
orb $-0x10, %bpl
movq (%rbx), %rax
movb %bpl, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x7a808
movq (%r15), %rsi
incq %rsi
callq 0x115c0
movq %r14, %rdi
callq 0x11a60
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::decodeUnicodeEscapeSequence(Json::Reader::Token&, char const*&, char const*, unsigned int&)
bool Reader::decodeUnicodeEscapeSequence(Token& token,
                                         Location& current,
                                         Location end,
                                         unsigned int& ret_unicode) {
  if (end - current < 4)
    return addError(
        "Bad unicode escape sequence in string: four digits expected.",
        token,
        current);
  int unicode = 0;
  for (int index = 0; index < 4; ++index) {
    Char c = *current++;
    unicode *= 16;
    if (c >= '0' && c <= '9')
      unicode += c - '0';
    else if (c >= 'a' && c <= 'f')
      unicode += c - 'a' + 10;
    else if (c >= 'A' && c <= 'F')
      unicode += c - 'A' + 10;
    else
      return addError(
          "Bad unicode escape sequence in string: hexadecimal digit expected.",
          token,
          current);
  }
  ret_unicode = static_cast<unsigned int>(unicode);
  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rax
subq %rax, %rcx
cmpq $0x4, %rcx
jge 0x7a880
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x44a89(%rip), %rsi     # 0xbf2ca
leaq 0x44abe(%rip), %rdx     # 0xbf306
leaq 0x8(%rsp), %rdi
callq 0x1a88c
movq (%r15), %rcx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x7894e
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7a87c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x115c0
xorl %eax, %eax
jmp 0x7a8ce
incq %rax
xorl %ecx, %ecx
movl $0x4, %edx
movq %rax, (%r15)
movsbl -0x1(%rax), %esi
shll $0x4, %ecx
leal -0x30(%rsi), %edi
cmpb $0x9, %dil
ja 0x7a8a4
addl %esi, %ecx
addl $-0x30, %ecx
jmp 0x7a8c2
leal -0x61(%rsi), %edi
cmpb $0x5, %dil
ja 0x7a8b4
addl %esi, %ecx
addl $-0x57, %ecx
jmp 0x7a8c2
leal -0x41(%rsi), %edi
cmpb $0x5, %dil
ja 0x7a8da
addl %esi, %ecx
addl $-0x37, %ecx
incq %rax
decl %edx
jne 0x7a88a
movl %ecx, (%r8)
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x44a1c(%rip), %rsi     # 0xbf307
leaq 0x44a57(%rip), %rdx     # 0xbf349
leaq 0x8(%rsp), %rdi
callq 0x1a88c
movq (%r15), %rcx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x7894e
jmp 0x7a865
jmp 0x7a918
jmp 0x7a934
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7a937
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x115c0
jmp 0x7a937
movq %rax, %rbx
movq %rbx, %rdi
callq 0x11a60
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::getLocationLineAndColumn(char const*, int&, int&) const
void Reader::getLocationLineAndColumn(Location location,
                                      int& line,
                                      int& column) const {
  Location current = begin_;
  Location lastLineStart = current;
  line = 0;
  while (current < location && current != end_) {
    Char c = *current++;
    if (c == '\r') {
      if (*current == '\n')
        ++current;
      lastLineStart = current;
      ++line;
    } else if (c == '\n') {
      lastLineStart = current;
      ++line;
    }
  }
  // column & line start at 1
  column = int(location - lastLineStart) + 1;
  ++line;
}

// Assembly:
movq 0xc0(%rdi), %r8
movl $0x0, (%rdx)
cmpq %rsi, %r8
jae 0x7a99c
cmpq 0xc8(%rdi), %r8
je 0x7a99c
xorl %eax, %eax
movq %r8, %r9
leaq 0x1(%r8), %r10
movzbl (%r8), %r11d
cmpl $0xa, %r11d
je 0x7a982
cmpl $0xd, %r11d
jne 0x7a989
cmpb $0xa, 0x1(%r8)
jne 0x7a982
addq $0x2, %r8
movq %r8, %r10
incl %eax
movl %eax, (%rdx)
movq %r10, %r9
movq %r10, %r8
cmpq %rsi, %r10
jae 0x7a99f
cmpq 0xc8(%rdi), %r8
jne 0x7a960
jmp 0x7a99f
movq %r8, %r9
subl %r9d, %esi
incl %esi
movl %esi, (%rcx)
incl (%rdx)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::getLocationLineAndColumn[abi:cxx11](char const*) const
std::string Reader::getLocationLineAndColumn(Location location) const {
  int line, column;
  getLocationLineAndColumn(location, line, column);
  char buffer[18 + 16 + 16 + 1];
  snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
  return buffer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %rsi, %rdi
movq %rdx, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x7a940
movl (%r14), %ecx
movl (%r15), %r8d
leaq 0x4496c(%rip), %rdx     # 0xbf34a
leaq 0x10(%rsp), %r14
movl $0x33, %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x11990
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x11260
leaq (%rsp,%rax), %rdx
addq $0x10, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a88c
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::getStructuredErrors() const
std::vector<Reader::StructuredError> Reader::getStructuredErrors() const {
  std::vector<Reader::StructuredError> allErrors;
  for (Errors::const_iterator itError = errors_.begin();
       itError != errors_.end();
       ++itError) {
    const ErrorInfo& error = *itError;
    Reader::StructuredError structured;
    structured.offset_start = error.token_.start_ - begin_;
    structured.offset_limit = error.token_.end_ - begin_;
    structured.message = error.message_;
    allErrors.push_back(structured);
  }
  return allErrors;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
pxor %xmm0, %xmm0
movdqu %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x60(%rsi), %r13
cmpq 0x80(%rsi), %r13
je 0x7af63
movq %rsi, %r14
movq 0x70(%rsi), %r12
movq 0x78(%rsi), %r15
leaq 0x20(%rsp), %rbp
movq %rbp, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
movdqu 0x8(%r13), %xmm0
movq 0xc0(%r14), %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
psubq %xmm1, %xmm0
movdqa %xmm0, (%rsp)
leaq 0x18(%r13), %rsi
leaq 0x10(%rsp), %rdi
callq 0x11300
movq %rbx, %rdi
movq %rsp, %rsi
callq 0x8789c
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7af3e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x115c0
addq $0x40, %r13
cmpq %r12, %r13
jne 0x7af56
movq 0x8(%r15), %r13
addq $0x8, %r15
leaq 0x200(%r13), %r12
cmpq 0x80(%r14), %r13
jne 0x7aede
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7af8f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x115c0
movq %rbx, %rdi
callq 0x878e0
movq %r14, %rdi
callq 0x11a60
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::pushError(Json::Value const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Reader::pushError(const Value& value, const std::string& message) {
  ptrdiff_t const length = end_ - begin_;
  if(value.getOffsetStart() > length
    || value.getOffsetLimit() > length)
    return false;
  Token token;
  token.type_ = tokenError;
  token.start_ = begin_ + value.getOffsetStart();
  token.end_ = end_ + value.getOffsetLimit();
  ErrorInfo info;
  info.token_ = token;
  info.message_ = message;
  info.extra_ = 0;
  errors_.push_back(info);
  return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0xc0(%rdi), %rcx
movq 0xc8(%rdi), %rax
movq %rax, %r8
subq %rcx, %r8
movq 0x18(%rsi), %rdi
cmpq %r8, %rdi
jg 0x7afd0
movq 0x20(%rsi), %rsi
cmpq %r8, %rsi
jle 0x7afd4
xorl %eax, %eax
jmp 0x7b03e
addq %rdi, %rcx
addq %rsi, %rax
leaq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movl $0xd, -0x28(%r14)
movq %rcx, -0x20(%r14)
movq %rax, -0x18(%r14)
movq %rdx, %rsi
callq 0x11300
leaq 0x8(%rsp), %rsi
movq $0x0, 0x38(%rsi)
addq $0x50, %rbx
movq %rbx, %rdi
callq 0x876ca
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x7b03c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x115c0
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x7b060
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x115c0
movq %rbx, %rdi
callq 0x11a60
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::pushError(Json::Value const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Json::Value const&)
bool Reader::pushError(const Value& value, const std::string& message, const Value& extra) {
  ptrdiff_t const length = end_ - begin_;
  if(value.getOffsetStart() > length
    || value.getOffsetLimit() > length
    || extra.getOffsetLimit() > length)
    return false;
  Token token;
  token.type_ = tokenError;
  token.start_ = begin_ + value.getOffsetStart();
  token.end_ = begin_ + value.getOffsetLimit();
  ErrorInfo info;
  info.token_ = token;
  info.message_ = message;
  info.extra_ = begin_ + extra.getOffsetStart();
  errors_.push_back(info);
  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rcx, %r14
movq %rdi, %rbx
movq 0xc0(%rdi), %rdi
movq 0xc8(%rbx), %r8
subq %rdi, %r8
movq 0x18(%rsi), %rcx
cmpq %r8, %rcx
jle 0x7b0a4
xorl %eax, %eax
jmp 0x7b124
movq 0x20(%rsi), %rsi
xorl %eax, %eax
cmpq %r8, %rsi
jg 0x7b124
cmpq %r8, 0x20(%r14)
jg 0x7b124
addq %rdi, %rcx
addq %rdi, %rsi
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movl $0xd, -0x28(%r15)
movq %rcx, -0x20(%r15)
movq %rsi, -0x18(%r15)
movq %rdx, %rsi
callq 0x11300
movq 0xc0(%rbx), %rax
addq 0x18(%r14), %rax
movq %rsp, %rsi
movq %rax, 0x38(%rsi)
addq $0x50, %rbx
movq %rbx, %rdi
callq 0x876ca
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x7b122
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x115c0
movb $0x1, %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x7b148
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x115c0
movq %rbx, %rdi
callq 0x11a60
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::OurReader::readStringSingleQuote()
bool OurReader::readStringSingleQuote() {
  Char c = 0;
  while (current_ != end_) {
    c = getNextChar();
    if (c == '\\')
      getNextChar();
    else if (c == '\'')
      break;
  }
  return c == '\'';
}

// Assembly:
movq 0xc8(%rdi), %rax
movq 0xd0(%rdi), %rdx
cmpq %rax, %rdx
je 0x7c8f3
leaq 0x1(%rdx), %rsi
movq %rsi, 0xd0(%rdi)
movzbl (%rdx), %ecx
cmpl $0x5c, %ecx
je 0x7c8d1
cmpl $0x27, %ecx
jne 0x7c8e4
jmp 0x7c8ec
cmpq %rax, %rsi
je 0x7c8e4
addq $0x2, %rdx
movq %rdx, 0xd0(%rdi)
movq %rdx, %rsi
movq %rsi, %rdx
cmpq %rax, %rsi
jne 0x7c8b7
cmpb $0x27, %cl
sete %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::OurReader::readNumber(bool)
bool OurReader::readNumber(bool checkInf) {
  const char *p = current_;
  if (checkInf && p != end_ && *p == 'I') {
    current_ = ++p;
    return false;
  }
  char c = '0'; // stopgap for already consumed character
  // integral part
  while (c >= '0' && c <= '9')
    c = (current_ = p) < end_ ? *p++ : 0;
  // fractional part
  if (c == '.') {
    c = (current_ = p) < end_ ? *p++ : 0;
    while (c >= '0' && c <= '9')
      c = (current_ = p) < end_ ? *p++ : 0;
  }
  // exponential part
  if (c == 'e' || c == 'E') {
    c = (current_ = p) < end_ ? *p++ : 0;
    if (c == '+' || c == '-')
      c = (current_ = p) < end_ ? *p++ : 0;
    while (c >= '0' && c <= '9')
      c = (current_ = p) < end_ ? *p++ : 0;
  }
  return true;
}

// Assembly:
movq 0xc8(%rdi), %rcx
movq 0xd0(%rdi), %rdx
cmpq %rcx, %rdx
setne %al
testb %al, %sil
je 0x7ca1b
cmpb $0x49, (%rdx)
jne 0x7ca1b
incq %rdx
movq %rdx, 0xd0(%rdi)
xorl %eax, %eax
retq
movq %rdx, 0xd0(%rdi)
movb $0x1, %al
cmpq %rcx, %rdx
jae 0x7cae3
movb (%rdx), %sil
incq %rdx
leal -0x30(%rsi), %r8d
cmpb $0xa, %r8b
jb 0x7ca1b
cmpb $0x2e, %sil
jne 0x7ca7f
movq %rdx, 0xd0(%rdi)
cmpq %rcx, %rdx
jae 0x7cae3
movb (%rdx), %sil
incq %rdx
leal -0x30(%rsi), %r8d
cmpb $0x9, %r8b
ja 0x7ca7f
movq %rdx, 0xd0(%rdi)
cmpq %rcx, %rdx
jae 0x7cae3
movb (%rdx), %sil
incq %rdx
leal -0x30(%rsi), %r8d
cmpb $0xa, %r8b
jb 0x7ca63
andb $-0x21, %sil
cmpb $0x45, %sil
jne 0x7cae3
movq %rdx, 0xd0(%rdi)
cmpq %rcx, %rdx
jae 0x7cae3
leaq 0x1(%rdx), %rsi
movzbl (%rdx), %r8d
cmpl $0x2d, %r8d
je 0x7caa9
cmpl $0x2b, %r8d
jne 0x7cac0
movq %rsi, 0xd0(%rdi)
cmpq %rcx, %rsi
jae 0x7cae3
movb 0x1(%rdx), %r8b
addq $0x2, %rdx
movq %rdx, %rsi
addb $-0x30, %r8b
cmpb $0x9, %r8b
ja 0x7cae3
movq %rsi, 0xd0(%rdi)
cmpq %rcx, %rsi
jae 0x7cae3
movb (%rsi), %dl
incq %rsi
addb $-0x30, %dl
cmpb $0xa, %dl
jb 0x7caca
retq