LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::isInt() const
bool Value::isInt() const {
  switch (type_) {
  case intValue:
    return value_.int_ >= minInt && value_.int_ <= maxInt;
  case uintValue:
    return value_.uint_ <= UInt(maxInt);
  case realValue:
    return value_.real_ >= minInt && value_.real_ <= maxInt &&
           IsIntegral(value_.real_);
  default:
    break;
  }
  return false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movzbl 0x8(%rax), %eax
movzwl %ax, %ecx
movl %ecx, 0x14(%rsp)
subw $0x1, %ax
je 0xee1ff
jmp 0xee1e6
movl 0x14(%rsp), %eax
subl $0x2, %eax
je 0xee232
jmp 0xee1f1
movl 0x14(%rsp), %eax
subl $0x3, %eax
je 0xee249
jmp 0xee29d
movq 0x8(%rsp), %rcx
xorl %eax, %eax
cmpq $-0x80000000, (%rcx)    # imm = 0x80000000
movb %al, 0x7(%rsp)
jl 0xee226
movq 0x8(%rsp), %rax
cmpq $0x7fffffff, (%rax)     # imm = 0x7FFFFFFF
setle %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xee2a4
movq 0x8(%rsp), %rax
cmpq $0x7fffffff, (%rax)     # imm = 0x7FFFFFFF
setbe %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xee2a4
movq 0x8(%rsp), %rax
movsd (%rax), %xmm0
xorl %eax, %eax
movsd 0x7bfe4(%rip), %xmm1    # 0x16a240
ucomisd %xmm1, %xmm0
movb %al, 0x6(%rsp)
jb 0xee291
movq 0x8(%rsp), %rcx
xorl %eax, %eax
movsd 0x7bfd3(%rip), %xmm0    # 0x16a248
ucomisd (%rcx), %xmm0
movb %al, 0x6(%rsp)
jb 0xee291
movq 0x8(%rsp), %rax
movsd (%rax), %xmm0
callq 0xf17a0
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xee2a4
jmp 0xee29f
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::isUInt() const
bool Value::isUInt() const {
  switch (type_) {
  case intValue:
    return value_.int_ >= 0 && LargestUInt(value_.int_) <= LargestUInt(maxUInt);
  case uintValue:
    return value_.uint_ <= maxUInt;
  case realValue:
    return value_.real_ >= 0 && value_.real_ <= maxUInt &&
           IsIntegral(value_.real_);
  default:
    break;
  }
  return false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movzbl 0x8(%rax), %eax
movzwl %ax, %ecx
movl %ecx, 0x14(%rsp)
subw $0x1, %ax
je 0xee6df
jmp 0xee6c6
movl 0x14(%rsp), %eax
subl $0x2, %eax
je 0xee710
jmp 0xee6d1
movl 0x14(%rsp), %eax
subl $0x3, %eax
je 0xee728
jmp 0xee777
movq 0x8(%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, 0x7(%rsp)
jl 0xee704
movq 0x8(%rsp), %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, (%rax)
setbe %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xee77e
movq 0x8(%rsp), %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, (%rax)
setbe %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xee77e
movq 0x8(%rsp), %rax
movsd (%rax), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb %al, 0x6(%rsp)
jb 0xee76b
movq 0x8(%rsp), %rcx
xorl %eax, %eax
movsd 0x7bb01(%rip), %xmm0    # 0x16a250
ucomisd (%rcx), %xmm0
movb %al, 0x6(%rsp)
jb 0xee76b
movq 0x8(%rsp), %rax
movsd (%rax), %xmm0
callq 0xf17a0
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xee77e
jmp 0xee779
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::isInt64() const
bool Value::isInt64() const {
#if defined(JSON_HAS_INT64)
  switch (type_) {
  case intValue:
    return true;
  case uintValue:
    return value_.uint_ <= UInt64(maxInt64);
  case realValue:
    // Note that maxInt64 (= 2^63 - 1) is not exactly representable as a
    // double, so double(maxInt64) will be rounded up to 2^63. Therefore we
    // require the value to be strictly less than the limit.
    return value_.real_ >= double(minInt64) &&
           value_.real_ < double(maxInt64) && IsIntegral(value_.real_);
  default:
    break;
  }
#endif // JSON_HAS_INT64
  return false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movzbl 0x8(%rax), %eax
movzwl %ax, %ecx
movl %ecx, 0x14(%rsp)
subw $0x1, %ax
je 0xeeb1c
jmp 0xeeb06
movl 0x14(%rsp), %eax
subl $0x2, %eax
je 0xeeb23
jmp 0xeeb11
movl 0x14(%rsp), %eax
subl $0x3, %eax
je 0xeeb40
jmp 0xeeb94
movb $0x1, 0x27(%rsp)
jmp 0xeeb9b
movq 0x8(%rsp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rcx, (%rax)
setbe %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xeeb9b
movq 0x8(%rsp), %rax
movsd (%rax), %xmm0
xorl %eax, %eax
movsd 0x7b705(%rip), %xmm1    # 0x16a258
ucomisd %xmm1, %xmm0
movb %al, 0x7(%rsp)
jb 0xeeb88
movq 0x8(%rsp), %rcx
xorl %eax, %eax
movsd 0x7a954(%rip), %xmm0    # 0x1694c0
ucomisd (%rcx), %xmm0
movb %al, 0x7(%rsp)
jbe 0xeeb88
movq 0x8(%rsp), %rax
movsd (%rax), %xmm0
callq 0xf17a0
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xeeb9b
jmp 0xeeb96
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::isUInt64() const
bool Value::isUInt64() const {
#if defined(JSON_HAS_INT64)
  switch (type_) {
  case intValue:
    return value_.int_ >= 0;
  case uintValue:
    return true;
  case realValue:
    // Note that maxUInt64 (= 2^64 - 1) is not exactly representable as a
    // double, so double(maxUInt64) will be rounded up to 2^64. Therefore we
    // require the value to be strictly less than the limit.
    return value_.real_ >= 0 && value_.real_ < maxUInt64AsDouble &&
           IsIntegral(value_.real_);
  default:
    break;
  }
#endif // JSON_HAS_INT64
  return false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movzbl 0x8(%rax), %eax
movzwl %ax, %ecx
movl %ecx, 0x14(%rsp)
subw $0x1, %ax
je 0xeef4c
jmp 0xeef36
movl 0x14(%rsp), %eax
subl $0x2, %eax
je 0xeef60
jmp 0xeef41
movl 0x14(%rsp), %eax
subl $0x3, %eax
je 0xeef67
jmp 0xeefb6
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
setge %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xeefbd
movb $0x1, 0x27(%rsp)
jmp 0xeefbd
movq 0x8(%rsp), %rax
movsd (%rax), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb %al, 0x7(%rsp)
jb 0xeefaa
movq 0x8(%rsp), %rcx
xorl %eax, %eax
movsd 0x7b2d2(%rip), %xmm0    # 0x16a260
ucomisd (%rcx), %xmm0
movb %al, 0x7(%rsp)
jbe 0xeefaa
movq 0x8(%rsp), %rax
movsd (%rax), %xmm0
callq 0xf17a0
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xeefbd
jmp 0xeefb8
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::asDouble() const
double Value::asDouble() const {
  switch (type_) {
  case intValue:
    return static_cast<double>(value_.int_);
  case uintValue:
#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
    return static_cast<double>(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 value_.real_;
  case nullValue:
    return 0.0;
  case booleanValue:
    return value_.bool_ ? 1.0 : 0.0;
  default:
    break;
  }
  JSON_FAIL_MESSAGE("Value is not convertible to double.");
}

// Assembly:
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rdi, 0x1d8(%rsp)
movq 0x1d8(%rsp), %rax
movq %rax, 0x20(%rsp)
movzbl 0x8(%rax), %eax
movzwl %ax, %ecx
movq %rcx, 0x28(%rsp)
subw $0x5, %ax
ja 0xef162
movq 0x28(%rsp), %rax
leaq 0x7af5e(%rip), %rcx     # 0x169ffc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x20(%rsp), %rax
cvtsi2sdq (%rax), %xmm0
movsd %xmm0, 0x1e0(%rsp)
jmp 0xef1e6
movq 0x20(%rsp), %rax
movq (%rax), %xmm0
movaps 0x7b141(%rip), %xmm1    # 0x16a210
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x7b145(%rip), %xmm1    # 0x16a220
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, 0x1e0(%rsp)
jmp 0xef1e6
movq 0x20(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x1e0(%rsp)
jmp 0xef1e6
xorps %xmm0, %xmm0
movsd %xmm0, 0x1e0(%rsp)
jmp 0xef1e6
movq 0x20(%rsp), %rax
movb (%rax), %al
movsd 0x76f01(%rip), %xmm0    # 0x166030
xorps %xmm1, %xmm1
movsd %xmm1, 0x10(%rsp)
testb $0x1, %al
movsd %xmm0, 0x18(%rsp)
jne 0xef14e
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x1e0(%rsp)
jmp 0xef1e6
jmp 0xef164
leaq 0x60(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x12980
movq 0x8(%rsp), %rdi
leaq 0x7b742(%rip), %rsi     # 0x16a8c1
callq 0x126b0
jmp 0xef186
leaq 0x30(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x12700
jmp 0xef197
leaq 0x30(%rsp), %rdi
callq 0xec480
jmp 0xef1a3
leaq 0x30(%rsp), %rdi
callq 0x12430
callq 0x12380
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0xef1da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x12430
leaq 0x60(%rsp), %rdi
callq 0x121a0
jmp 0xef1f7
movsd 0x1e0(%rsp), %xmm0
addq $0x1e8, %rsp            # imm = 0x1E8
retq
movq 0x58(%rsp), %rdi
callq 0x12c20
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.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)
    // This can fail (silently?) if the value is bigger than MAX_FLOAT.
    return static_cast<float>(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:
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rdi, 0x1d8(%rsp)
movq 0x1d8(%rsp), %rax
movq %rax, 0x20(%rsp)
movzbl 0x8(%rax), %eax
movzwl %ax, %ecx
movq %rcx, 0x28(%rsp)
subw $0x5, %ax
ja 0xef332
movq 0x28(%rsp), %rax
leaq 0x7adc6(%rip), %rcx     # 0x16a014
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x20(%rsp), %rax
cvtsi2ssq (%rax), %xmm0
movss %xmm0, 0x1e4(%rsp)
jmp 0xef3b6
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, 0x18(%rsp)
testq %rax, %rax
movss %xmm0, 0x1c(%rsp)
js 0xef2b0
movss 0x18(%rsp), %xmm0
movss %xmm0, 0x1c(%rsp)
movss 0x1c(%rsp), %xmm0
movss %xmm0, 0x1e4(%rsp)
jmp 0xef3b6
movq 0x20(%rsp), %rax
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x1e4(%rsp)
jmp 0xef3b6
xorps %xmm0, %xmm0
movss %xmm0, 0x1e4(%rsp)
jmp 0xef3b6
movq 0x20(%rsp), %rax
movb (%rax), %al
movss 0x77d4d(%rip), %xmm0    # 0x16704c
xorps %xmm1, %xmm1
movss %xmm1, 0x10(%rsp)
testb $0x1, %al
movss %xmm0, 0x14(%rsp)
jne 0xef31e
movss 0x10(%rsp), %xmm0
movss %xmm0, 0x14(%rsp)
movss 0x14(%rsp), %xmm0
movss %xmm0, 0x1e4(%rsp)
jmp 0xef3b6
jmp 0xef334
leaq 0x60(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x12980
movq 0x8(%rsp), %rdi
leaq 0x7b596(%rip), %rsi     # 0x16a8e5
callq 0x126b0
jmp 0xef356
leaq 0x30(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x12700
jmp 0xef367
leaq 0x30(%rsp), %rdi
callq 0xec480
jmp 0xef373
leaq 0x30(%rsp), %rdi
callq 0x12430
callq 0x12380
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0xef3aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x12430
leaq 0x60(%rsp), %rdi
callq 0x121a0
jmp 0xef3c7
movss 0x1e4(%rsp), %xmm0
addq $0x1e8, %rsp            # imm = 0x1E8
retq
movq 0x58(%rsp), %rdi
callq 0x12c20
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::empty() const
bool Value::empty() const {
  if (isNull() || isArray() || isObject())
    return size() == 0u;
  else
    return false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xef930
testb $0x1, %al
jne 0xef907
movq (%rsp), %rdi
callq 0xe0a60
testb $0x1, %al
jne 0xef907
movq (%rsp), %rdi
callq 0xe0a80
testb $0x1, %al
jne 0xef907
jmp 0xef91e
movq (%rsp), %rdi
callq 0xeb340
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0xef923
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::clear()
void Value::clear() {
  JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == arrayValue ||
                          type_ == objectValue,
                      "in Json::Value::clear(): requires complex value");
  start_ = 0;
  limit_ = 0;
  switch (type_) {
  case arrayValue:
  case objectValue:
    value_.map_->clear();
    break;
  default:
    break;
  }
}

// Assembly:
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdi, 0x1c0(%rsp)
movq 0x1c0(%rsp), %rax
movq %rax, 0x10(%rsp)
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0xefa54
movq 0x10(%rsp), %rax
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x6, %eax
je 0xefa54
movq 0x10(%rsp), %rax
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x7, %eax
je 0xefa54
leaq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x12980
movq 0x8(%rsp), %rdi
leaq 0x7af3d(%rip), %rsi     # 0x16a92a
callq 0x126b0
jmp 0xef9f4
leaq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x12700
jmp 0xefa05
leaq 0x18(%rsp), %rdi
callq 0xec480
jmp 0xefa11
leaq 0x18(%rsp), %rdi
callq 0x12430
callq 0x12380
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0xefa48
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x12430
leaq 0x48(%rsp), %rdi
callq 0x121a0
jmp 0xefa90
movq 0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movzbl 0x8(%rax), %eax
addl $-0x6, %eax
subl $0x1, %eax
ja 0xefa86
jmp 0xefa77
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0xfa350
jmp 0xefa88
jmp 0xefa88
addq $0x1c8, %rsp            # imm = 0x1C8
retq
movq 0x40(%rsp), %rdi
callq 0x12c20
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::resize(unsigned int)
void Value::resize(ArrayIndex newSize) {
  JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == arrayValue,
                      "in Json::Value::resize(): requires arrayValue");
  if (type_ == nullValue)
    *this = Value(arrayValue);
  ArrayIndex oldSize = size();
  if (newSize == 0)
    clear();
  else if (newSize > oldSize)
    (*this)[newSize - 1];
  else {
    for (ArrayIndex index = newSize; index < oldSize; ++index) {
      value_.map_->erase(index);
    }
    assert(size() == newSize);
  }
}

// Assembly:
subq $0x228, %rsp            # imm = 0x228
movq %rdi, 0x220(%rsp)
movl %esi, 0x21c(%rsp)
movq 0x220(%rsp), %rax
movq %rax, 0x28(%rsp)
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0xefb8a
movq 0x28(%rsp), %rax
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x6, %eax
je 0xefb8a
leaq 0xa0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x12980
movq 0x20(%rsp), %rdi
leaq 0x7ae4c(%rip), %rsi     # 0x16a95a
callq 0x126b0
jmp 0xefb15
leaq 0x70(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x12700
jmp 0xefb29
leaq 0x70(%rsp), %rdi
callq 0xec480
jmp 0xefb35
leaq 0x70(%rsp), %rdi
callq 0x12430
callq 0x12380
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0xefb78
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x12430
leaq 0xa0(%rsp), %rdi
callq 0x121a0
jmp 0xefcc6
movq 0x28(%rsp), %rax
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0xefbf3
leaq 0x48(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x6, %esi
callq 0xecc20
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xe3700
jmp 0xefbc4
leaq 0x48(%rsp), %rdi
callq 0xed680
jmp 0xefbf3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xed680
jmp 0xefcc6
movq 0x28(%rsp), %rdi
callq 0xeb340
movl %eax, 0x44(%rsp)
cmpl $0x0, 0x21c(%rsp)
jne 0xefc1a
movq 0x28(%rsp), %rdi
callq 0xef970
jmp 0xefcbe
movl 0x21c(%rsp), %eax
cmpl 0x44(%rsp), %eax
jbe 0xefc3d
movq 0x28(%rsp), %rdi
movl 0x21c(%rsp), %esi
subl $0x1, %esi
callq 0xefce0
jmp 0xefcbc
movl 0x21c(%rsp), %eax
movl %eax, 0x40(%rsp)
movl 0x40(%rsp), %eax
cmpl 0x44(%rsp), %eax
jae 0xefcba
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x40(%rsp), %esi
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xec840
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xfa360
jmp 0xefc83
leaq 0x30(%rsp), %rdi
callq 0xec9f0
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0xefc48
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xec9f0
jmp 0xefcc6
jmp 0xefcbc
jmp 0xefcbe
addq $0x228, %rsp            # imm = 0x228
retq
movq 0x98(%rsp), %rdi
callq 0x12c20
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::operator[](unsigned int) const
const Value& Value::operator[](ArrayIndex index) const {
  JSON_ASSERT_MESSAGE(
      type_ == nullValue || type_ == arrayValue,
      "in Json::Value::operator[](ArrayIndex)const: requires arrayValue");
  if (type_ == nullValue)
    return nullRef;
  CZString key(index);
  ObjectValues::const_iterator it = value_.map_->find(key);
  if (it == value_.map_->end())
    return nullRef;
  return (*it).second;
}

// Assembly:
subq $0x218, %rsp            # imm = 0x218
movq %rdi, 0x208(%rsp)
movl %esi, 0x204(%rsp)
movq 0x208(%rsp), %rax
movq %rax, 0x18(%rsp)
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0xf0104
movq 0x18(%rsp), %rax
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x6, %eax
je 0xf0104
leaq 0x88(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x12980
movq 0x10(%rsp), %rdi
leaq 0x7a976(%rip), %rsi     # 0x16aa04
callq 0x126b0
jmp 0xf0095
leaq 0x58(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x12700
jmp 0xf00a9
leaq 0x58(%rsp), %rdi
callq 0xec480
jmp 0xf00b5
leaq 0x58(%rsp), %rdi
callq 0x12430
callq 0x12380
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0xf00f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x12430
leaq 0x88(%rsp), %rdi
callq 0x121a0
jmp 0xf0217
movq 0x18(%rsp), %rax
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0xf012d
movq 0xc0400(%rip), %rax     # 0x1b0520
movq %rax, 0x210(%rsp)
jmp 0xf0207
movl 0x204(%rsp), %esi
leaq 0x48(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xec840
movq 0x18(%rsp), %rax
movq (%rsp), %rsi
movq (%rax), %rdi
callq 0xfa4a0
movq %rax, 0x8(%rsp)
jmp 0xf015a
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xfa2d0
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0xfa2a0
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xfa2d0
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xfa4d0
testb $0x1, %al
jne 0xf01a9
jmp 0xf01df
movq 0xc0370(%rip), %rax     # 0x1b0520
movq %rax, 0x210(%rsp)
movl $0x1, 0x24(%rsp)
jmp 0xf01fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xec9f0
jmp 0xf0217
leaq 0x40(%rsp), %rdi
callq 0xfa320
addq $0x10, %rax
movq %rax, 0x210(%rsp)
movl $0x1, 0x24(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xec9f0
movq 0x210(%rsp), %rax
addq $0x218, %rsp            # imm = 0x218
retq
movq 0x80(%rsp), %rdi
callq 0x12c20
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::operator[](int) const
const Value& Value::operator[](int index) const {
  JSON_ASSERT_MESSAGE(
      index >= 0,
      "in Json::Value::operator[](int index) const: index cannot be negative");
  return (*this)[ArrayIndex(index)];
}

// Assembly:
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdi, 0x1c0(%rsp)
movl %esi, 0x1bc(%rsp)
movq 0x1c0(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x1bc(%rsp)
jge 0xf02e1
leaq 0x40(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x12980
movq (%rsp), %rdi
leaq 0x7a7cb(%rip), %rsi     # 0x16aa45
callq 0x126b0
jmp 0xf0281
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x12700
jmp 0xf0292
leaq 0x10(%rsp), %rdi
callq 0xec480
jmp 0xf029e
leaq 0x10(%rsp), %rdi
callq 0x12430
callq 0x12380
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0xf02d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x12430
leaq 0x40(%rsp), %rdi
callq 0x121a0
jmp 0xf02fa
movq 0x8(%rsp), %rdi
movl 0x1bc(%rsp), %esi
callq 0xf0020
addq $0x1c8, %rsp            # imm = 0x1C8
retq
movq 0x38(%rsp), %rdi
callq 0x12c20
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::find(char const*, char const*) const
Value const* Value::find(char const* key, char const* cend) 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>(cend-key), CZString::noDuplication);
  ObjectValues::const_iterator it = value_.map_->find(actualKey);
  if (it == value_.map_->end()) return NULL;
  return &(*it).second;
}

// Assembly:
subq $0x228, %rsp            # imm = 0x228
movq %rdi, 0x218(%rsp)
movq %rsi, 0x210(%rsp)
movq %rdx, 0x208(%rsp)
movq 0x218(%rsp), %rax
movq %rax, 0x20(%rsp)
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0xf0b93
movq 0x20(%rsp), %rax
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x7, %eax
je 0xf0b93
leaq 0x90(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x12980
movq 0x18(%rsp), %rdi
leaq 0x79fee(%rip), %rsi     # 0x16ab05
callq 0x126b0
jmp 0xf0b1e
leaq 0x60(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x12700
jmp 0xf0b32
leaq 0x60(%rsp), %rdi
callq 0xec480
jmp 0xf0b3e
leaq 0x60(%rsp), %rdi
callq 0x12430
callq 0x12380
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0xf0b81
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x12430
leaq 0x90(%rsp), %rdi
callq 0x121a0
jmp 0xf0cb3
movq 0x20(%rsp), %rax
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0xf0bb9
movq $0x0, 0x220(%rsp)
jmp 0xf0ca3
movq 0x210(%rsp), %rsi
movl 0x208(%rsp), %edx
movl %esi, %eax
subl %eax, %edx
leaq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %ecx, %ecx
callq 0xec860
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rsi
movq (%rax), %rdi
callq 0xfa4a0
movq %rax, 0x10(%rsp)
jmp 0xf0bf6
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xfa2d0
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0xfa2a0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xfa2d0
leaq 0x48(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xfa4d0
testb $0x1, %al
jne 0xf0c45
jmp 0xf0c7b
movq $0x0, 0x220(%rsp)
movl $0x1, 0x2c(%rsp)
jmp 0xf0c99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xec9f0
jmp 0xf0cb3
leaq 0x48(%rsp), %rdi
callq 0xfa320
addq $0x10, %rax
movq %rax, 0x220(%rsp)
movl $0x1, 0x2c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xec9f0
movq 0x220(%rsp), %rax
addq $0x228, %rsp            # imm = 0x228
retq
movq 0x88(%rsp), %rdi
callq 0x12c20
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::removeMember(char const*, char const*, Json::Value*)
bool Value::removeMember(const char* key, const char* cend, Value* removed)
{
  if (type_ != objectValue) {
    return false;
  }
  CZString actualKey(key, static_cast<unsigned>(cend-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:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq %rdx, 0x98(%rsp)
movq %rcx, 0x90(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x18(%rsp)
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x7, %eax
je 0xf0f61
movb $0x0, 0xb7(%rsp)
jmp 0xf10aa
movq 0xa0(%rsp), %rsi
movl 0x98(%rsp), %edx
movl %esi, %eax
subl %eax, %edx
leaq 0x80(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %ecx, %ecx
callq 0xec860
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rsi
movq (%rax), %rdi
callq 0xfa4a0
movq %rax, 0x10(%rsp)
jmp 0xf0fa1
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x78(%rsp)
movq (%rax), %rdi
callq 0xfa2a0
movq %rax, 0x60(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xf9f70
testb $0x1, %al
jne 0xf0fd2
jmp 0xf0ffa
movb $0x0, 0xb7(%rsp)
movl $0x1, 0x5c(%rsp)
jmp 0xf108c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0xf109b
leaq 0x78(%rsp), %rdi
callq 0xf9ed0
movq %rax, %rsi
addq $0x10, %rsi
leaq 0x30(%rsp), %rdi
callq 0xed200
jmp 0xf1017
movq 0x90(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xe3700
jmp 0xf102b
leaq 0x30(%rsp), %rdi
callq 0xed680
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x78(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rsi
callq 0xfa4f0
movq %rax, (%rsp)
jmp 0xf1057
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movb $0x1, 0xb7(%rsp)
movl $0x1, 0x5c(%rsp)
jmp 0xf108c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xed680
jmp 0xf109b
leaq 0x80(%rsp), %rdi
callq 0xec9f0
jmp 0xf10aa
leaq 0x80(%rsp), %rdi
callq 0xec9f0
jmp 0xf10bb
movb 0xb7(%rsp), %al
andb $0x1, %al
addq $0xb8, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0x12c20
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::removeMember(char const*)
Value Value::removeMember(const char* key)
{
  JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == objectValue,
                      "in Json::Value::removeMember(): requires objectValue");
  if (type_ == nullValue)
    return nullRef;

  Value removed;  // null
  removeMember(key, key + strlen(key), &removed);
  return removed; // still null if removeMember() did nothing
}

// Assembly:
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x1f0(%rsp)
movq %rsi, 0x1e8(%rsp)
movq %rdx, 0x1e0(%rsp)
movq 0x1e8(%rsp), %rax
movq %rax, 0x28(%rsp)
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0xf128b
movq 0x28(%rsp), %rax
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x7, %eax
je 0xf128b
leaq 0x68(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x12980
movq 0x10(%rsp), %rdi
leaq 0x7992d(%rip), %rsi     # 0x16ab4e
callq 0x126b0
jmp 0xf1228
leaq 0x38(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x12700
jmp 0xf1239
leaq 0x38(%rsp), %rdi
callq 0xec480
jmp 0xf1245
leaq 0x38(%rsp), %rdi
callq 0x12430
callq 0x12380
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xf127c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x12430
leaq 0x68(%rsp), %rdi
callq 0x121a0
jmp 0xf1333
movq 0x28(%rsp), %rax
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0xf12b3
movq 0x18(%rsp), %rdi
movq 0xbf274(%rip), %rsi     # 0x1b0520
callq 0xed200
jmp 0xf1326
movq 0x18(%rsp), %rdi
movb $0x0, 0x37(%rsp)
xorl %esi, %esi
callq 0xecc20
movq 0x1e0(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x122b0
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rcx
movq %rsi, %rdx
addq %rax, %rdx
callq 0xf0f10
jmp 0xf12f2
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0xf1324
jmp 0xf131a
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
callq 0xed680
jmp 0xf1333
movq 0x18(%rsp), %rdi
callq 0xed680
jmp 0xf1326
movq 0x20(%rsp), %rax
addq $0x1f8, %rsp            # imm = 0x1F8
retq
movq 0x60(%rsp), %rdi
callq 0x12c20
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::isIntegral() const
bool Value::isIntegral() const {
#if defined(JSON_HAS_INT64)
  return isInt64() || isUInt64();
#else
  return isInt() || isUInt();
#endif
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xeeae0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0xf1801
movq (%rsp), %rdi
callq 0xeef10
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::setComment(char const*, unsigned long, Json::CommentPlacement)
void Value::setComment(const char* comment, size_t len, CommentPlacement placement) {
  if (!comments_)
    comments_ = new CommentInfo[numberOfCommentPlacement];
  if ((len > 0) && (comment[len-1] == '\n')) {
    // Always discard trailing newline, to aid indentation.
    len -= 1;
  }
  comments_[placement].setComment(comment, len);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movl %ecx, 0x5c(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x10(%rax)
jne 0xf195d
movl $0x20, %edi
callq 0x12040
movq %rax, 0x20(%rsp)
movq $0x3, (%rax)
addq $0x8, %rax
movq %rax, 0x28(%rsp)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x30(%rsp)
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xec4f0
jmp 0xf18dd
movq 0x30(%rsp), %rcx
movq 0x18(%rsp), %rax
addq $0x8, %rax
cmpq %rcx, %rax
movq %rax, 0x38(%rsp)
jne 0xf18cc
movq 0x40(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x10(%rax)
jmp 0xf195d
movq 0x28(%rsp), %rcx
movq %rax, %rsi
movq 0x18(%rsp), %rax
movq %rsi, 0x50(%rsp)
movl %edx, 0x4c(%rsp)
cmpq %rax, %rcx
movq %rax, 0x10(%rsp)
je 0xf194c
movq 0x10(%rsp), %rdi
addq $-0x8, %rdi
movq %rdi, 0x8(%rsp)
callq 0xec510
movq 0x28(%rsp), %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x10(%rsp)
jne 0xf1925
movq 0x20(%rsp), %rdi
movl $0x20, %esi
callq 0x12d80
jmp 0xf19b2
cmpq $0x0, 0x60(%rsp)
jbe 0xf198a
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0xf198a
movq 0x60(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x60(%rsp)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x5c(%rsp), %eax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x68(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0xec560
addq $0x78, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x12c20
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::StyledWriter::write[abi:cxx11](Json::Value const&)
std::string StyledWriter::write(const Value& root) {
  document_ = "";
  addChildValues_ = false;
  indentString_ = "";
  writeCommentBeforeValue(root);
  writeValue(root);
  writeCommentAfterValueOnSameLine(root);
  document_ += "\n";
  return document_;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x20, %rdi
leaq 0x759ea(%rip), %rsi     # 0x1675ff
callq 0x129a0
movq 0x8(%rsp), %rdi
movb $0x0, 0x68(%rdi)
addq $0x40, %rdi
leaq 0x759d1(%rip), %rsi     # 0x1675ff
callq 0x129a0
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xf4000
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xf41b0
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xf49b0
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
leaq 0x7b2d2(%rip), %rsi     # 0x16cf42
callq 0x12670
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
addq $0x20, %rsi
callq 0x122a0
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.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 $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movzbl 0x8(%rax), %eax
addl $-0x6, %eax
subl $0x1, %eax
ja 0xf1cee
jmp 0xf1cc0
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0xf1cec
movq (%rsp), %rax
movq (%rax), %rdi
callq 0xfa740
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xec130
jmp 0xf1cfa
jmp 0xf1cf0
jmp 0xf1cf0
leaq 0x18(%rsp), %rdi
callq 0xec120
movq 0x18(%rsp), %rax
movb 0x20(%rsp), %dl
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.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 $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movzbl 0x8(%rax), %eax
addl $-0x6, %eax
subl $0x1, %eax
ja 0xf1d5e
jmp 0xf1d30
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0xf1d5c
movq (%rsp), %rax
movq (%rax), %rdi
callq 0xfa2a0
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xec130
jmp 0xf1d6a
jmp 0xf1d60
jmp 0xf1d60
leaq 0x18(%rsp), %rdi
callq 0xec120
movq 0x18(%rsp), %rax
movb 0x20(%rsp), %dl
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.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:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movzbl 0x8(%rax), %eax
addl $-0x6, %eax
subl $0x1, %eax
ja 0xf1de3
jmp 0xf1db3
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0xf1de1
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0xfa740
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0xec1d0
jmp 0xf1def
jmp 0xf1de5
jmp 0xf1de5
movq 0x8(%rsp), %rdi
callq 0xec1c0
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.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:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movzbl 0x8(%rax), %eax
addl $-0x6, %eax
subl $0x1, %eax
ja 0xf1e63
jmp 0xf1e33
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0xf1e61
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0xfa2a0
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0xec1d0
jmp 0xf1e6f
jmp 0xf1e65
jmp 0xf1e65
movq 0x8(%rsp), %rdi
callq 0xec1c0
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Path::Path(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Json::PathArgument const&, Json::PathArgument const&, Json::PathArgument const&, Json::PathArgument const&, Json::PathArgument const&)
Path::Path(const std::string& path,
           const PathArgument& a1,
           const PathArgument& a2,
           const PathArgument& a3,
           const PathArgument& a4,
           const PathArgument& a5) {
  InArgs in;
  in.push_back(&a1);
  in.push_back(&a2);
  in.push_back(&a3);
  in.push_back(&a4);
  in.push_back(&a5);
  makePath(path, in);
}

// Assembly:
subq $0x98, %rsp
movq 0xa0(%rsp), %rax
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movq %r8, 0x70(%rsp)
movq %r9, 0x68(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0xfa850
leaq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xfa860
movq 0x10(%rsp), %rdi
movq 0x80(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x48(%rsp), %rsi
callq 0xfa870
jmp 0xf208c
movq 0x78(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xfa870
jmp 0xf20a7
movq 0x70(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xfa870
jmp 0xf20c2
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xfa870
jmp 0xf20dd
movq 0xa0(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xfa870
jmp 0xf20fb
movq 0x8(%rsp), %rdi
movq 0x88(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0xf2160
jmp 0xf2114
leaq 0x50(%rsp), %rdi
callq 0xfa8a0
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xfa8a0
movq (%rsp), %rdi
callq 0xfa900
movq 0x40(%rsp), %rdi
callq 0x12c20
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Path::addPathInArg(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<Json::PathArgument const*, std::allocator<Json::PathArgument const*>> const&, __gnu_cxx::__normal_iterator<Json::PathArgument const* const*, std::vector<Json::PathArgument const*, std::allocator<Json::PathArgument const*>>>&, Json::PathArgument::Kind)
void Path::addPathInArg(const std::string& /*path*/,
                        const InArgs& in,
                        InArgs::const_iterator& itInArg,
                        PathArgument::Kind kind) {
  if (itInArg == in.end()) {
    // Error: missing argument %d
  } else if ((*itInArg)->kind_ != kind) {
    // Error: bad argument type
  } else {
    args_.push_back(**itInArg);
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movl %r8d, 0x24(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0xfaa10
movq 0x10(%rsp), %rdi
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0xfa9d0
testb $0x1, %al
jne 0xf2625
jmp 0xf2627
jmp 0xf2658
movq 0x28(%rsp), %rdi
callq 0xfaa40
movq (%rax), %rax
movl 0x24(%rax), %eax
cmpl 0x24(%rsp), %eax
je 0xf263f
jmp 0xf2656
movq 0x28(%rsp), %rdi
callq 0xfaa40
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
callq 0xfaa50
jmp 0xf2658
addq $0x48, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Path::resolve(Json::Value const&) const
const Value& Path::resolve(const Value& root) const {
  const Value* node = &root;
  for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) {
    const PathArgument& arg = *it;
    if (arg.kind_ == PathArgument::kindIndex) {
      if (!node->isArray() || !node->isValidIndex(arg.index_)) {
        // Error: unable to resolve path (array value expected at position...
      }
      node = &((*node)[arg.index_]);
    } else if (arg.kind_ == PathArgument::kindKey) {
      if (!node->isObject()) {
        // Error: unable to resolve path (object value expected at position...)
      }
      node = &((*node)[arg.key_]);
      if (node == &Value::nullRef) {
        // Error: unable to resolve path (object has no member named '' at
        // position...)
      }
    }
  }
  return *node;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0xfaac0
movq %rax, 0x18(%rsp)
movq (%rsp), %rdi
callq 0xfab30
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xfaaf0
testb $0x1, %al
jne 0xf26c1
jmp 0xf2770
leaq 0x18(%rsp), %rdi
callq 0xfab60
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x1, 0x24(%rax)
jne 0xf271c
movq 0x20(%rsp), %rdi
callq 0xe0a60
testb $0x1, %al
jne 0xf26eb
jmp 0xf2701
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x20(%rax), %esi
callq 0xf0a60
testb $0x1, %al
jne 0xf2703
jmp 0xf2703
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x20(%rax), %esi
callq 0xf0020
movq %rax, 0x20(%rsp)
jmp 0xf275f
movq 0x8(%rsp), %rax
cmpl $0x2, 0x24(%rax)
jne 0xf275d
movq 0x20(%rsp), %rdi
callq 0xe0a80
testb $0x1, %al
jne 0xf2737
jmp 0xf2737
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xeb2b0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0xbddc9(%rip), %rax     # 0x1b0520
jne 0xf275b
jmp 0xf275b
jmp 0xf275d
jmp 0xf275f
jmp 0xf2761
leaq 0x18(%rsp), %rdi
callq 0xfab70
jmp 0xf269b
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Path::resolve(Json::Value const&, Json::Value const&) const
Value Path::resolve(const Value& root, const Value& defaultValue) const {
  const Value* node = &root;
  for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) {
    const PathArgument& arg = *it;
    if (arg.kind_ == PathArgument::kindIndex) {
      if (!node->isArray() || !node->isValidIndex(arg.index_))
        return defaultValue;
      node = &((*node)[arg.index_]);
    } else if (arg.kind_ == PathArgument::kindKey) {
      if (!node->isObject())
        return defaultValue;
      node = &((*node)[arg.key_]);
      if (node == &Value::nullRef)
        return defaultValue;
    }
  }
  return *node;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
callq 0xfaac0
movq %rax, 0x28(%rsp)
movq 0x10(%rsp), %rdi
callq 0xfab30
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xfaaf0
testb $0x1, %al
jne 0xf27e9
jmp 0xf28c5
leaq 0x28(%rsp), %rdi
callq 0xfab60
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x1, 0x24(%rax)
jne 0xf2855
movq 0x30(%rsp), %rdi
callq 0xe0a60
testb $0x1, %al
jne 0xf2813
jmp 0xf2829
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0x20(%rax), %esi
callq 0xf0a60
testb $0x1, %al
jne 0xf283c
movq (%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xed200
jmp 0xf28d3
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0x20(%rax), %esi
callq 0xf0020
movq %rax, 0x30(%rsp)
jmp 0xf28b4
movq 0x18(%rsp), %rax
cmpl $0x2, 0x24(%rax)
jne 0xf28b2
movq 0x30(%rsp), %rdi
callq 0xe0a80
testb $0x1, %al
jne 0xf287e
movq (%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xed200
jmp 0xf28d3
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xeb2b0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0xbdc82(%rip), %rax     # 0x1b0520
jne 0xf28b0
movq (%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xed200
jmp 0xf28d3
jmp 0xf28b2
jmp 0xf28b4
jmp 0xf28b6
leaq 0x28(%rsp), %rdi
callq 0xfab70
jmp 0xf27c2
movq (%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xed200
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Path::make(Json::Value&) const
Value& Path::make(Value& root) const {
  Value* node = &root;
  for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) {
    const PathArgument& arg = *it;
    if (arg.kind_ == PathArgument::kindIndex) {
      if (!node->isArray()) {
        // Error: node is not an array at position ...
      }
      node = &((*node)[arg.index_]);
    } else if (arg.kind_ == PathArgument::kindKey) {
      if (!node->isObject()) {
        // Error: node is not an object at position...
      }
      node = &((*node)[arg.key_]);
    }
  }
  return *node;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0xfaac0
movq %rax, 0x18(%rsp)
movq (%rsp), %rdi
callq 0xfab30
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xfaaf0
testb $0x1, %al
jne 0xf2931
jmp 0xf29b6
leaq 0x18(%rsp), %rdi
callq 0xfab60
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x1, 0x24(%rax)
jne 0xf2974
movq 0x20(%rsp), %rdi
callq 0xe0a60
testb $0x1, %al
jne 0xf295b
jmp 0xf295b
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x20(%rax), %esi
callq 0xefce0
movq %rax, 0x20(%rsp)
jmp 0xf29a5
movq 0x8(%rsp), %rax
cmpl $0x2, 0x24(%rax)
jne 0xf29a3
movq 0x20(%rsp), %rdi
callq 0xe0a80
testb $0x1, %al
jne 0xf298f
jmp 0xf298f
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xe3230
movq %rax, 0x20(%rsp)
jmp 0xf29a5
jmp 0xf29a7
leaq 0x18(%rsp), %rdi
callq 0xfab70
jmp 0xf290b
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::uintToString(unsigned long long, char*&)
static inline void uintToString(LargestUInt value, char*& current) {
  *--current = 0;
  do {
    *--current = static_cast<signed char>(value % 10U + static_cast<unsigned>('0'));
    value /= 10;
  } while (value != 0);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, (%rcx)
movb $0x0, -0x1(%rax)
movq -0x8(%rsp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
addq $0x30, %rdx
movb %dl, %cl
movq -0x10(%rsp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $-0x1, %rsi
movq %rsi, (%rdx)
movb %cl, -0x1(%rax)
movq -0x8(%rsp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x8(%rsp)
cmpq $0x0, -0x8(%rsp)
jne 0xf29e0
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::fixNumericLocale(char*, char*)
static inline void fixNumericLocale(char* begin, char* end) {
  while (begin < end) {
    if (*begin == ',') {
      *begin = '.';
    }
    ++begin;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
cmpq -0x10(%rsp), %rax
jae 0xf2cab
movq -0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0xf2c9b
movq -0x8(%rsp), %rax
movb $0x2e, (%rax)
movq -0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rsp)
jmp 0xf2c7a
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::containsControlCharacter(char const*)
static bool containsControlCharacter(const char* str) {
  while (*str) {
    if (isControlCharacter(*(str++)))
      return true;
  }
  return false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0xf330b
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rsp)
movsbl (%rax), %edi
callq 0xf3320
testb $0x1, %al
jne 0xf3302
jmp 0xf3309
movb $0x1, 0x17(%rsp)
jmp 0xf3310
jmp 0xf32d9
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::FastWriter::write[abi:cxx11](Json::Value const&)
std::string FastWriter::write(const Value& root) {
  document_ = "";
  writeValue(root);
  if (!omitEndingLineFeed_)
    document_ += "\n";
  return document_;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x8, %rdi
leaq 0x741da(%rip), %rsi     # 0x1675ff
callq 0x129a0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xf3480
movq 0x18(%rsp), %rax
testb $0x1, 0x2a(%rax)
jne 0xf3459
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
leaq 0x79aee(%rip), %rsi     # 0x16cf42
callq 0x12670
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x8, %rsi
callq 0x122a0
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)