#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int append_string(char *, char *);
size_t strlen(char const *);
int json_serialize_string(const char *string, char *buf) {
  size_t i = 0, len = strlen(string);
  char c = '\0';
  int written = -1, written_total = 0;
  do {
    written = append_string(buf, ("\""));
    if (written < 0) {
      return -1;
    }
    if (buf != NULL) {
      buf += written;
    }
    written_total += written;
  } while (0);
  for (i = 0; i < len; i++) {
    c = string[i];
    switch (c) {
    case '\"':
      do {
        written = append_string(buf, ("\\\""));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\\':
      do {
        written = append_string(buf, ("\\\\"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '/':
      do {
        written = append_string(buf, ("\\/"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\b':
      do {
        written = append_string(buf, ("\\b"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\f':
      do {
        written = append_string(buf, ("\\f"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\n':
      do {
        written = append_string(buf, ("\\n"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\r':
      do {
        written = append_string(buf, ("\\r"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\t':
      do {
        written = append_string(buf, ("\\t"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\x00':
      do {
        written = append_string(buf, ("\\u0000"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\x01':
      do {
        written = append_string(buf, ("\\u0001"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\x02':
      do {
        written = append_string(buf, ("\\u0002"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\x03':
      do {
        written = append_string(buf, ("\\u0003"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\x04':
      do {
        written = append_string(buf, ("\\u0004"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\x05':
      do {
        written = append_string(buf, ("\\u0005"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\x06':
      do {
        written = append_string(buf, ("\\u0006"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\x07':
      do {
        written = append_string(buf, ("\\u0007"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\x0b':
      do {
        written = append_string(buf, ("\\u000b"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\x0e':
      do {
        written = append_string(buf, ("\\u000e"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\x0f':
      do {
        written = append_string(buf, ("\\u000f"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\x10':
      do {
        written = append_string(buf, ("\\u0010"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\x11':
      do {
        written = append_string(buf, ("\\u0011"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\x12':
      do {
        written = append_string(buf, ("\\u0012"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\x13':
      do {
        written = append_string(buf, ("\\u0013"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\x14':
      do {
        written = append_string(buf, ("\\u0014"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\x15':
      do {
        written = append_string(buf, ("\\u0015"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\x16':
      do {
        written = append_string(buf, ("\\u0016"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\x17':
      do {
        written = append_string(buf, ("\\u0017"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\x18':
      do {
        written = append_string(buf, ("\\u0018"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\x19':
      do {
        written = append_string(buf, ("\\u0019"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\x1a':
      do {
        written = append_string(buf, ("\\u001a"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\x1b':
      do {
        written = append_string(buf, ("\\u001b"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\x1c':
      do {
        written = append_string(buf, ("\\u001c"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\x1d':
      do {
        written = append_string(buf, ("\\u001d"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\x1e':
      do {
        written = append_string(buf, ("\\u001e"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    case '\x1f':
      do {
        written = append_string(buf, ("\\u001f"));
        if (written < 0) {
          return -1;
        }
        if (buf != NULL) {
          buf += written;
        }
        written_total += written;
      } while (0);
      break;
    default:
      if (buf != NULL) {
        buf[0] = c;
        buf += 1;
      }
      written_total += 1;
      break;
    }
  }
  do {
    written = append_string(buf, ("\""));
    if (written < 0) {
      return -1;
    }
    if (buf != NULL) {
      buf += written;
    }
    written_total += written;
  } while (0);
  return written_total;
}


x86 assembly (clang, -O0):
<json_serialize_string>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movq   $0x0,-0x20(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x28(%rbp)
movb   $0x0,-0x29(%rbp)
movl   $0xffffffff,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x18(%rbp),%rdi
lea    0x1013(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    1180 <json_serialize_string+0x60>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     119c <json_serialize_string+0x7c>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    1e37 <json_serialize_string+0xd17>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x29(%rbp)
movsbl -0x29(%rbp),%eax
mov    %eax,%ecx
mov    %rcx,-0x40(%rbp)
sub    $0x5c,%eax
ja     1df8 <json_serialize_string+0xcd8>
mov    -0x40(%rbp),%rax
lea    0xe19(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
jmp    11f5 <json_serialize_string+0xd5>
mov    -0x18(%rbp),%rdi
lea    0xf74(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    121e <json_serialize_string+0xfe>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     123a <json_serialize_string+0x11a>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    124d <json_serialize_string+0x12d>
mov    -0x18(%rbp),%rdi
lea    0xf1f(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    1276 <json_serialize_string+0x156>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     1292 <json_serialize_string+0x172>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    12a5 <json_serialize_string+0x185>
mov    -0x18(%rbp),%rdi
lea    0xeca(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    12ce <json_serialize_string+0x1ae>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     12ea <json_serialize_string+0x1ca>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    12fd <json_serialize_string+0x1dd>
mov    -0x18(%rbp),%rdi
lea    0xe75(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    1326 <json_serialize_string+0x206>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     1342 <json_serialize_string+0x222>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    1355 <json_serialize_string+0x235>
mov    -0x18(%rbp),%rdi
lea    0xe20(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    137e <json_serialize_string+0x25e>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     139a <json_serialize_string+0x27a>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    13ad <json_serialize_string+0x28d>
mov    -0x18(%rbp),%rdi
lea    0xdcb(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    13d6 <json_serialize_string+0x2b6>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     13f2 <json_serialize_string+0x2d2>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    1405 <json_serialize_string+0x2e5>
mov    -0x18(%rbp),%rdi
lea    0xd76(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    142e <json_serialize_string+0x30e>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     144a <json_serialize_string+0x32a>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    145d <json_serialize_string+0x33d>
mov    -0x18(%rbp),%rdi
lea    0xd21(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    1486 <json_serialize_string+0x366>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     14a2 <json_serialize_string+0x382>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    14b5 <json_serialize_string+0x395>
mov    -0x18(%rbp),%rdi
lea    0xccc(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    14de <json_serialize_string+0x3be>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     14fa <json_serialize_string+0x3da>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    150d <json_serialize_string+0x3ed>
mov    -0x18(%rbp),%rdi
lea    0xc7b(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    1536 <json_serialize_string+0x416>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     1552 <json_serialize_string+0x432>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    1565 <json_serialize_string+0x445>
mov    -0x18(%rbp),%rdi
lea    0xc2a(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    158e <json_serialize_string+0x46e>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     15aa <json_serialize_string+0x48a>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    15bd <json_serialize_string+0x49d>
mov    -0x18(%rbp),%rdi
lea    0xbd9(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    15e6 <json_serialize_string+0x4c6>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     1602 <json_serialize_string+0x4e2>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    1615 <json_serialize_string+0x4f5>
mov    -0x18(%rbp),%rdi
lea    0xb88(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    163e <json_serialize_string+0x51e>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     165a <json_serialize_string+0x53a>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    166d <json_serialize_string+0x54d>
mov    -0x18(%rbp),%rdi
lea    0xb37(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    1696 <json_serialize_string+0x576>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     16b2 <json_serialize_string+0x592>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    16c5 <json_serialize_string+0x5a5>
mov    -0x18(%rbp),%rdi
lea    0xae6(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    16ee <json_serialize_string+0x5ce>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     170a <json_serialize_string+0x5ea>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    171d <json_serialize_string+0x5fd>
mov    -0x18(%rbp),%rdi
lea    0xa95(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    1746 <json_serialize_string+0x626>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     1762 <json_serialize_string+0x642>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    1775 <json_serialize_string+0x655>
mov    -0x18(%rbp),%rdi
lea    0xa44(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    179e <json_serialize_string+0x67e>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     17ba <json_serialize_string+0x69a>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    17cd <json_serialize_string+0x6ad>
mov    -0x18(%rbp),%rdi
lea    0x9f3(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    17f6 <json_serialize_string+0x6d6>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     1812 <json_serialize_string+0x6f2>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    1825 <json_serialize_string+0x705>
mov    -0x18(%rbp),%rdi
lea    0x9a2(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    184e <json_serialize_string+0x72e>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     186a <json_serialize_string+0x74a>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    187d <json_serialize_string+0x75d>
mov    -0x18(%rbp),%rdi
lea    0x951(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    18a6 <json_serialize_string+0x786>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     18c2 <json_serialize_string+0x7a2>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    18d5 <json_serialize_string+0x7b5>
mov    -0x18(%rbp),%rdi
lea    0x900(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    18fe <json_serialize_string+0x7de>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     191a <json_serialize_string+0x7fa>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    192d <json_serialize_string+0x80d>
mov    -0x18(%rbp),%rdi
lea    0x8af(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    1956 <json_serialize_string+0x836>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     1972 <json_serialize_string+0x852>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    1985 <json_serialize_string+0x865>
mov    -0x18(%rbp),%rdi
lea    0x85e(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    19ae <json_serialize_string+0x88e>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     19ca <json_serialize_string+0x8aa>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    19dd <json_serialize_string+0x8bd>
mov    -0x18(%rbp),%rdi
lea    0x80d(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    1a06 <json_serialize_string+0x8e6>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     1a22 <json_serialize_string+0x902>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    1a35 <json_serialize_string+0x915>
mov    -0x18(%rbp),%rdi
lea    0x7bc(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    1a5e <json_serialize_string+0x93e>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     1a7a <json_serialize_string+0x95a>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    1a8d <json_serialize_string+0x96d>
mov    -0x18(%rbp),%rdi
lea    0x76b(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    1ab6 <json_serialize_string+0x996>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     1ad2 <json_serialize_string+0x9b2>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    1ae5 <json_serialize_string+0x9c5>
mov    -0x18(%rbp),%rdi
lea    0x71a(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    1b0e <json_serialize_string+0x9ee>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     1b2a <json_serialize_string+0xa0a>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    1b3d <json_serialize_string+0xa1d>
mov    -0x18(%rbp),%rdi
lea    0x6c9(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    1b66 <json_serialize_string+0xa46>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     1b82 <json_serialize_string+0xa62>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    1b95 <json_serialize_string+0xa75>
mov    -0x18(%rbp),%rdi
lea    0x678(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    1bbe <json_serialize_string+0xa9e>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     1bda <json_serialize_string+0xaba>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    1bed <json_serialize_string+0xacd>
mov    -0x18(%rbp),%rdi
lea    0x627(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    1c16 <json_serialize_string+0xaf6>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     1c32 <json_serialize_string+0xb12>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    1c45 <json_serialize_string+0xb25>
mov    -0x18(%rbp),%rdi
lea    0x5d6(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    1c6e <json_serialize_string+0xb4e>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     1c8a <json_serialize_string+0xb6a>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    1c9d <json_serialize_string+0xb7d>
mov    -0x18(%rbp),%rdi
lea    0x585(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    1cc6 <json_serialize_string+0xba6>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     1ce2 <json_serialize_string+0xbc2>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    1cf5 <json_serialize_string+0xbd5>
mov    -0x18(%rbp),%rdi
lea    0x534(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    1d1e <json_serialize_string+0xbfe>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     1d3a <json_serialize_string+0xc1a>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    1d4d <json_serialize_string+0xc2d>
mov    -0x18(%rbp),%rdi
lea    0x4e3(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    1d76 <json_serialize_string+0xc56>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     1d92 <json_serialize_string+0xc72>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
jmp    1da5 <json_serialize_string+0xc85>
mov    -0x18(%rbp),%rdi
lea    0x492(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    1dce <json_serialize_string+0xcae>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     1dea <json_serialize_string+0xcca>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1e21 <json_serialize_string+0xd01>
cmpq   $0x0,-0x18(%rbp)
je     1e18 <json_serialize_string+0xcf8>
mov    -0x29(%rbp),%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1e26 <json_serialize_string+0xd06>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    11ad <json_serialize_string+0x8d>
jmp    1e3c <json_serialize_string+0xd1c>
mov    -0x18(%rbp),%rdi
lea    0x32e(%rip),%rsi
call   1040 <append_string@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    1e65 <json_serialize_string+0xd45>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e90 <json_serialize_string+0xd70>
cmpq   $0x0,-0x18(%rbp)
je     1e81 <json_serialize_string+0xd61>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<json_serialize_string>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rsi,%rbp
mov    %rdi,%r12
call   1030 <strlen@plt>
mov    %rax,%r15
lea    0x1035(%rip),%rsi
mov    %rbp,%rdi
call   1040 <append_string@plt>
mov    %eax,%r13d
mov    $0xffffffff,%eax
test   %r13d,%r13d
js     1373 <json_serialize_string+0x253>
mov    %r13d,%ebx
add    %rbp,%rbx
test   %rbp,%rbp
cmove  %rbp,%rbx
test   %r15,%r15
je     134f <json_serialize_string+0x22f>
xor    %ebp,%ebp
lea    0xe88(%rip),%r14
nopl   0x0(%rax,%rax,1)
movsbl (%r12,%rbp,1),%eax
cmp    $0x5c,%eax
ja     133a <json_serialize_string+0x21a>
movslq (%r14,%rax,4),%rcx
add    %r14,%rcx
jmp    *%rcx
lea    0xfee(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xfe9(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xfe4(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xfdf(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xfda(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xfd5(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xfd0(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xfcb(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xf7f(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xf7f(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xf6d(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xfa2(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xf52(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xf4c(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xf85(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xf80(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xf7b(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xf76(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xf71(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xf6c(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xf67(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xf62(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xf60(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xf5e(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xf5c(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xf5a(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xf58(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xf56(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xf54(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xf52(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xf50(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xf4e(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xe77(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xe74(%rip),%rsi
jmp    1310 <json_serialize_string+0x1f0>
lea    0xe68(%rip),%rsi
nop
mov    %rbx,%rdi
call   1040 <append_string@plt>
test   %eax,%eax
js     136e <json_serialize_string+0x24e>
mov    %eax,%ecx
add    %rbx,%rcx
test   %rbx,%rbx
cmovne %rcx,%rbx
add    %eax,%r13d
add    $0x1,%rbp
cmp    %rbp,%r15
jne    1180 <json_serialize_string+0x60>
jmp    134f <json_serialize_string+0x22f>
test   %rbx,%rbx
je     1347 <json_serialize_string+0x227>
mov    %al,(%rbx)
add    $0x1,%rbx
jmp    1349 <json_serialize_string+0x229>
xor    %ebx,%ebx
add    $0x1,%r13d
jmp    132b <json_serialize_string+0x20b>
lea    0xe1f(%rip),%rsi
mov    %rbx,%rdi
call   1040 <append_string@plt>
add    %eax,%r13d
test   %eax,%eax
mov    $0xffffffff,%eax
cmovns %r13d,%eax
jmp    1373 <json_serialize_string+0x253>
mov    $0xffffffff,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [2 x i8] c"\22\00"
@.str.1 = [3 x i8] c"\\\22\00"
@.str.2 = [3 x i8] c"\\\\\00"
@.str.3 = [3 x i8] c"\\/\00"
@.str.4 = [3 x i8] c"\\b\00"
@.str.5 = [3 x i8] c"\\f\00"
@.str.6 = [3 x i8] c"\\n\00"
@.str.7 = [3 x i8] c"\\r\00"
@.str.8 = [3 x i8] c"\\t\00"
@.str.9 = [7 x i8] c"\\u0000\00"
@.str.10 = [7 x i8] c"\\u0001\00"
@.str.11 = [7 x i8] c"\\u0002\00"
@.str.12 = [7 x i8] c"\\u0003\00"
@.str.13 = [7 x i8] c"\\u0004\00"
@.str.14 = [7 x i8] c"\\u0005\00"
@.str.15 = [7 x i8] c"\\u0006\00"
@.str.16 = [7 x i8] c"\\u0007\00"
@.str.17 = [7 x i8] c"\\u000b\00"
@.str.18 = [7 x i8] c"\\u000e\00"
@.str.19 = [7 x i8] c"\\u000f\00"
@.str.20 = [7 x i8] c"\\u0010\00"
@.str.21 = [7 x i8] c"\\u0011\00"
@.str.22 = [7 x i8] c"\\u0012\00"
@.str.23 = [7 x i8] c"\\u0013\00"
@.str.24 = [7 x i8] c"\\u0014\00"
@.str.25 = [7 x i8] c"\\u0015\00"
@.str.26 = [7 x i8] c"\\u0016\00"
@.str.27 = [7 x i8] c"\\u0017\00"
@.str.28 = [7 x i8] c"\\u0018\00"
@.str.29 = [7 x i8] c"\\u0019\00"
@.str.30 = [7 x i8] c"\\u001a\00"
@.str.31 = [7 x i8] c"\\u001b\00"
@.str.32 = [7 x i8] c"\\u001c\00"
@.str.33 = [7 x i8] c"\\u001d\00"
@.str.34 = [7 x i8] c"\\u001e\00"
@.str.35 = [7 x i8] c"\\u001f\00"
define i32 @json_serialize_string(i8* %0, i8* %1) {
%3 = alloca i32
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i64
%7 = alloca i64
%8 = alloca i8
%9 = alloca i32
%10 = alloca i32
store i8* %0, i8** %4
store i8* %1, i8** %5
store i64 0, i64* %6
%11 = load i8*, i8** %4
%12 = call i64 @strlen(i8* %11)
store i64 %12, i64* %7
store i8 0, i8* %8
store i32 -1, i32* %9
store i32 0, i32* %10
br label %13
13: ; preds = %2
%14 = load i8*, i8** %5
%15 = call i32 @append_string(i8* %14, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
store i32 %15, i32* %9
%16 = load i32, i32* %9
%17 = icmp slt i32 %16, 0
br i1 %17, label %18, label %19
18: ; preds = %13
store i32 -1, i32* %3
br label %780
19: ; preds = %13
%20 = load i8*, i8** %5
%21 = icmp ne i8* %20, null
br i1 %21, label %22, label %27
22: ; preds = %19
%23 = load i32, i32* %9
%24 = load i8*, i8** %5
%25 = sext i32 %23 to i64
%26 = getelementptr inbounds i8, i8* %24, i64 %25
store i8* %26, i8** %5
br label %27
27: ; preds = %22, %19
%28 = load i32, i32* %9
%29 = load i32, i32* %10
%30 = add nsw i32 %29, %28
store i32 %30, i32* %10
br label %31
31: ; preds = %27
store i64 0, i64* %6
br label %32
32: ; preds = %756, %31
%33 = load i64, i64* %6
%34 = load i64, i64* %7
%35 = icmp ult i64 %33, %34
br i1 %35, label %36, label %759
36: ; preds = %32
%37 = load i8*, i8** %4
%38 = load i64, i64* %6
%39 = getelementptr inbounds i8, i8* %37, i64 %38
%40 = load i8, i8* %39
store i8 %40, i8* %8
%41 = load i8, i8* %8
%42 = sext i8 %41 to i32
switch i32 %42, label %743 [
i32 34, label %43
i32 92, label %63
i32 47, label %83
i32 8, label %103
i32 12, label %123
i32 10, label %143
i32 13, label %163
i32 9, label %183
i32 0, label %203
i32 1, label %223
i32 2, label %243
i32 3, label %263
i32 4, label %283
i32 5, label %303
i32 6, label %323
i32 7, label %343
i32 11, label %363
i32 14, label %383
i32 15, label %403
i32 16, label %423
i32 17, label %443
i32 18, label %463
i32 19, label %483
i32 20, label %503
i32 21, label %523
i32 22, label %543
i32 23, label %563
i32 24, label %583
i32 25, label %603
i32 26, label %623
i32 27, label %643
i32 28, label %663
i32 29, label %683
i32 30, label %703
i32 31, label %723
]
43: ; preds = %36
br label %44
44: ; preds = %43
%45 = load i8*, i8** %5
%46 = call i32 @append_string(i8* %45, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i32 %46, i32* %9
%47 = load i32, i32* %9
%48 = icmp slt i32 %47, 0
br i1 %48, label %49, label %50
49: ; preds = %44
store i32 -1, i32* %3
br label %780
50: ; preds = %44
%51 = load i8*, i8** %5
%52 = icmp ne i8* %51, null
br i1 %52, label %53, label %58
53: ; preds = %50
%54 = load i32, i32* %9
%55 = load i8*, i8** %5
%56 = sext i32 %54 to i64
%57 = getelementptr inbounds i8, i8* %55, i64 %56
store i8* %57, i8** %5
br label %58
58: ; preds = %53, %50
%59 = load i32, i32* %9
%60 = load i32, i32* %10
%61 = add nsw i32 %60, %59
store i32 %61, i32* %10
br label %62
62: ; preds = %58
br label %755
63: ; preds = %36
br label %64
64: ; preds = %63
%65 = load i8*, i8** %5
%66 = call i32 @append_string(i8* %65, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
store i32 %66, i32* %9
%67 = load i32, i32* %9
%68 = icmp slt i32 %67, 0
br i1 %68, label %69, label %70
69: ; preds = %64
store i32 -1, i32* %3
br label %780
70: ; preds = %64
%71 = load i8*, i8** %5
%72 = icmp ne i8* %71, null
br i1 %72, label %73, label %78
73: ; preds = %70
%74 = load i32, i32* %9
%75 = load i8*, i8** %5
%76 = sext i32 %74 to i64
%77 = getelementptr inbounds i8, i8* %75, i64 %76
store i8* %77, i8** %5
br label %78
78: ; preds = %73, %70
%79 = load i32, i32* %9
%80 = load i32, i32* %10
%81 = add nsw i32 %80, %79
store i32 %81, i32* %10
br label %82
82: ; preds = %78
br label %755
83: ; preds = %36
br label %84
84: ; preds = %83
%85 = load i8*, i8** %5
%86 = call i32 @append_string(i8* %85, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0))
store i32 %86, i32* %9
%87 = load i32, i32* %9
%88 = icmp slt i32 %87, 0
br i1 %88, label %89, label %90
89: ; preds = %84
store i32 -1, i32* %3
br label %780
90: ; preds = %84
%91 = load i8*, i8** %5
%92 = icmp ne i8* %91, null
br i1 %92, label %93, label %98
93: ; preds = %90
%94 = load i32, i32* %9
%95 = load i8*, i8** %5
%96 = sext i32 %94 to i64
%97 = getelementptr inbounds i8, i8* %95, i64 %96
store i8* %97, i8** %5
br label %98
98: ; preds = %93, %90
%99 = load i32, i32* %9
%100 = load i32, i32* %10
%101 = add nsw i32 %100, %99
store i32 %101, i32* %10
br label %102
102: ; preds = %98
br label %755
103: ; preds = %36
br label %104
104: ; preds = %103
%105 = load i8*, i8** %5
%106 = call i32 @append_string(i8* %105, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0))
store i32 %106, i32* %9
%107 = load i32, i32* %9
%108 = icmp slt i32 %107, 0
br i1 %108, label %109, label %110
109: ; preds = %104
store i32 -1, i32* %3
br label %780
110: ; preds = %104
%111 = load i8*, i8** %5
%112 = icmp ne i8* %111, null
br i1 %112, label %113, label %118
113: ; preds = %110
%114 = load i32, i32* %9
%115 = load i8*, i8** %5
%116 = sext i32 %114 to i64
%117 = getelementptr inbounds i8, i8* %115, i64 %116
store i8* %117, i8** %5
br label %118
118: ; preds = %113, %110
%119 = load i32, i32* %9
%120 = load i32, i32* %10
%121 = add nsw i32 %120, %119
store i32 %121, i32* %10
br label %122
122: ; preds = %118
br label %755
123: ; preds = %36
br label %124
124: ; preds = %123
%125 = load i8*, i8** %5
%126 = call i32 @append_string(i8* %125, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0))
store i32 %126, i32* %9
%127 = load i32, i32* %9
%128 = icmp slt i32 %127, 0
br i1 %128, label %129, label %130
129: ; preds = %124
store i32 -1, i32* %3
br label %780
130: ; preds = %124
%131 = load i8*, i8** %5
%132 = icmp ne i8* %131, null
br i1 %132, label %133, label %138
133: ; preds = %130
%134 = load i32, i32* %9
%135 = load i8*, i8** %5
%136 = sext i32 %134 to i64
%137 = getelementptr inbounds i8, i8* %135, i64 %136
store i8* %137, i8** %5
br label %138
138: ; preds = %133, %130
%139 = load i32, i32* %9
%140 = load i32, i32* %10
%141 = add nsw i32 %140, %139
store i32 %141, i32* %10
br label %142
142: ; preds = %138
br label %755
143: ; preds = %36
br label %144
144: ; preds = %143
%145 = load i8*, i8** %5
%146 = call i32 @append_string(i8* %145, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
store i32 %146, i32* %9
%147 = load i32, i32* %9
%148 = icmp slt i32 %147, 0
br i1 %148, label %149, label %150
149: ; preds = %144
store i32 -1, i32* %3
br label %780
150: ; preds = %144
%151 = load i8*, i8** %5
%152 = icmp ne i8* %151, null
br i1 %152, label %153, label %158
153: ; preds = %150
%154 = load i32, i32* %9
%155 = load i8*, i8** %5
%156 = sext i32 %154 to i64
%157 = getelementptr inbounds i8, i8* %155, i64 %156
store i8* %157, i8** %5
br label %158
158: ; preds = %153, %150
%159 = load i32, i32* %9
%160 = load i32, i32* %10
%161 = add nsw i32 %160, %159
store i32 %161, i32* %10
br label %162
162: ; preds = %158
br label %755
163: ; preds = %36
br label %164
164: ; preds = %163
%165 = load i8*, i8** %5
%166 = call i32 @append_string(i8* %165, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i64 0, i64 0))
store i32 %166, i32* %9
%167 = load i32, i32* %9
%168 = icmp slt i32 %167, 0
br i1 %168, label %169, label %170
169: ; preds = %164
store i32 -1, i32* %3
br label %780
170: ; preds = %164
%171 = load i8*, i8** %5
%172 = icmp ne i8* %171, null
br i1 %172, label %173, label %178
173: ; preds = %170
%174 = load i32, i32* %9
%175 = load i8*, i8** %5
%176 = sext i32 %174 to i64
%177 = getelementptr inbounds i8, i8* %175, i64 %176
store i8* %177, i8** %5
br label %178
178: ; preds = %173, %170
%179 = load i32, i32* %9
%180 = load i32, i32* %10
%181 = add nsw i32 %180, %179
store i32 %181, i32* %10
br label %182
182: ; preds = %178
br label %755
183: ; preds = %36
br label %184
184: ; preds = %183
%185 = load i8*, i8** %5
%186 = call i32 @append_string(i8* %185, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0))
store i32 %186, i32* %9
%187 = load i32, i32* %9
%188 = icmp slt i32 %187, 0
br i1 %188, label %189, label %190
189: ; preds = %184
store i32 -1, i32* %3
br label %780
190: ; preds = %184
%191 = load i8*, i8** %5
%192 = icmp ne i8* %191, null
br i1 %192, label %193, label %198
193: ; preds = %190
%194 = load i32, i32* %9
%195 = load i8*, i8** %5
%196 = sext i32 %194 to i64
%197 = getelementptr inbounds i8, i8* %195, i64 %196
store i8* %197, i8** %5
br label %198
198: ; preds = %193, %190
%199 = load i32, i32* %9
%200 = load i32, i32* %10
%201 = add nsw i32 %200, %199
store i32 %201, i32* %10
br label %202
202: ; preds = %198
br label %755
203: ; preds = %36
br label %204
204: ; preds = %203
%205 = load i8*, i8** %5
%206 = call i32 @append_string(i8* %205, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.9, i64 0, i64 0))
store i32 %206, i32* %9
%207 = load i32, i32* %9
%208 = icmp slt i32 %207, 0
br i1 %208, label %209, label %210
209: ; preds = %204
store i32 -1, i32* %3
br label %780
210: ; preds = %204
%211 = load i8*, i8** %5
%212 = icmp ne i8* %211, null
br i1 %212, label %213, label %218
213: ; preds = %210
%214 = load i32, i32* %9
%215 = load i8*, i8** %5
%216 = sext i32 %214 to i64
%217 = getelementptr inbounds i8, i8* %215, i64 %216
store i8* %217, i8** %5
br label %218
218: ; preds = %213, %210
%219 = load i32, i32* %9
%220 = load i32, i32* %10
%221 = add nsw i32 %220, %219
store i32 %221, i32* %10
br label %222
222: ; preds = %218
br label %755
223: ; preds = %36
br label %224
224: ; preds = %223
%225 = load i8*, i8** %5
%226 = call i32 @append_string(i8* %225, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.10, i64 0, i64 0))
store i32 %226, i32* %9
%227 = load i32, i32* %9
%228 = icmp slt i32 %227, 0
br i1 %228, label %229, label %230
229: ; preds = %224
store i32 -1, i32* %3
br label %780
230: ; preds = %224
%231 = load i8*, i8** %5
%232 = icmp ne i8* %231, null
br i1 %232, label %233, label %238
233: ; preds = %230
%234 = load i32, i32* %9
%235 = load i8*, i8** %5
%236 = sext i32 %234 to i64
%237 = getelementptr inbounds i8, i8* %235, i64 %236
store i8* %237, i8** %5
br label %238
238: ; preds = %233, %230
%239 = load i32, i32* %9
%240 = load i32, i32* %10
%241 = add nsw i32 %240, %239
store i32 %241, i32* %10
br label %242
242: ; preds = %238
br label %755
243: ; preds = %36
br label %244
244: ; preds = %243
%245 = load i8*, i8** %5
%246 = call i32 @append_string(i8* %245, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.11, i64 0, i64 0))
store i32 %246, i32* %9
%247 = load i32, i32* %9
%248 = icmp slt i32 %247, 0
br i1 %248, label %249, label %250
249: ; preds = %244
store i32 -1, i32* %3
br label %780
250: ; preds = %244
%251 = load i8*, i8** %5
%252 = icmp ne i8* %251, null
br i1 %252, label %253, label %258
253: ; preds = %250
%254 = load i32, i32* %9
%255 = load i8*, i8** %5
%256 = sext i32 %254 to i64
%257 = getelementptr inbounds i8, i8* %255, i64 %256
store i8* %257, i8** %5
br label %258
258: ; preds = %253, %250
%259 = load i32, i32* %9
%260 = load i32, i32* %10
%261 = add nsw i32 %260, %259
store i32 %261, i32* %10
br label %262
262: ; preds = %258
br label %755
263: ; preds = %36
br label %264
264: ; preds = %263
%265 = load i8*, i8** %5
%266 = call i32 @append_string(i8* %265, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.12, i64 0, i64 0))
store i32 %266, i32* %9
%267 = load i32, i32* %9
%268 = icmp slt i32 %267, 0
br i1 %268, label %269, label %270
269: ; preds = %264
store i32 -1, i32* %3
br label %780
270: ; preds = %264
%271 = load i8*, i8** %5
%272 = icmp ne i8* %271, null
br i1 %272, label %273, label %278
273: ; preds = %270
%274 = load i32, i32* %9
%275 = load i8*, i8** %5
%276 = sext i32 %274 to i64
%277 = getelementptr inbounds i8, i8* %275, i64 %276
store i8* %277, i8** %5
br label %278
278: ; preds = %273, %270
%279 = load i32, i32* %9
%280 = load i32, i32* %10
%281 = add nsw i32 %280, %279
store i32 %281, i32* %10
br label %282
282: ; preds = %278
br label %755
283: ; preds = %36
br label %284
284: ; preds = %283
%285 = load i8*, i8** %5
%286 = call i32 @append_string(i8* %285, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.13, i64 0, i64 0))
store i32 %286, i32* %9
%287 = load i32, i32* %9
%288 = icmp slt i32 %287, 0
br i1 %288, label %289, label %290
289: ; preds = %284
store i32 -1, i32* %3
br label %780
290: ; preds = %284
%291 = load i8*, i8** %5
%292 = icmp ne i8* %291, null
br i1 %292, label %293, label %298
293: ; preds = %290
%294 = load i32, i32* %9
%295 = load i8*, i8** %5
%296 = sext i32 %294 to i64
%297 = getelementptr inbounds i8, i8* %295, i64 %296
store i8* %297, i8** %5
br label %298
298: ; preds = %293, %290
%299 = load i32, i32* %9
%300 = load i32, i32* %10
%301 = add nsw i32 %300, %299
store i32 %301, i32* %10
br label %302
302: ; preds = %298
br label %755
303: ; preds = %36
br label %304
304: ; preds = %303
%305 = load i8*, i8** %5
%306 = call i32 @append_string(i8* %305, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.14, i64 0, i64 0))
store i32 %306, i32* %9
%307 = load i32, i32* %9
%308 = icmp slt i32 %307, 0
br i1 %308, label %309, label %310
309: ; preds = %304
store i32 -1, i32* %3
br label %780
310: ; preds = %304
%311 = load i8*, i8** %5
%312 = icmp ne i8* %311, null
br i1 %312, label %313, label %318
313: ; preds = %310
%314 = load i32, i32* %9
%315 = load i8*, i8** %5
%316 = sext i32 %314 to i64
%317 = getelementptr inbounds i8, i8* %315, i64 %316
store i8* %317, i8** %5
br label %318
318: ; preds = %313, %310
%319 = load i32, i32* %9
%320 = load i32, i32* %10
%321 = add nsw i32 %320, %319
store i32 %321, i32* %10
br label %322
322: ; preds = %318
br label %755
323: ; preds = %36
br label %324
324: ; preds = %323
%325 = load i8*, i8** %5
%326 = call i32 @append_string(i8* %325, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.15, i64 0, i64 0))
store i32 %326, i32* %9
%327 = load i32, i32* %9
%328 = icmp slt i32 %327, 0
br i1 %328, label %329, label %330
329: ; preds = %324
store i32 -1, i32* %3
br label %780
330: ; preds = %324
%331 = load i8*, i8** %5
%332 = icmp ne i8* %331, null
br i1 %332, label %333, label %338
333: ; preds = %330
%334 = load i32, i32* %9
%335 = load i8*, i8** %5
%336 = sext i32 %334 to i64
%337 = getelementptr inbounds i8, i8* %335, i64 %336
store i8* %337, i8** %5
br label %338
338: ; preds = %333, %330
%339 = load i32, i32* %9
%340 = load i32, i32* %10
%341 = add nsw i32 %340, %339
store i32 %341, i32* %10
br label %342
342: ; preds = %338
br label %755
343: ; preds = %36
br label %344
344: ; preds = %343
%345 = load i8*, i8** %5
%346 = call i32 @append_string(i8* %345, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.16, i64 0, i64 0))
store i32 %346, i32* %9
%347 = load i32, i32* %9
%348 = icmp slt i32 %347, 0
br i1 %348, label %349, label %350
349: ; preds = %344
store i32 -1, i32* %3
br label %780
350: ; preds = %344
%351 = load i8*, i8** %5
%352 = icmp ne i8* %351, null
br i1 %352, label %353, label %358
353: ; preds = %350
%354 = load i32, i32* %9
%355 = load i8*, i8** %5
%356 = sext i32 %354 to i64
%357 = getelementptr inbounds i8, i8* %355, i64 %356
store i8* %357, i8** %5
br label %358
358: ; preds = %353, %350
%359 = load i32, i32* %9
%360 = load i32, i32* %10
%361 = add nsw i32 %360, %359
store i32 %361, i32* %10
br label %362
362: ; preds = %358
br label %755
363: ; preds = %36
br label %364
364: ; preds = %363
%365 = load i8*, i8** %5
%366 = call i32 @append_string(i8* %365, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.17, i64 0, i64 0))
store i32 %366, i32* %9
%367 = load i32, i32* %9
%368 = icmp slt i32 %367, 0
br i1 %368, label %369, label %370
369: ; preds = %364
store i32 -1, i32* %3
br label %780
370: ; preds = %364
%371 = load i8*, i8** %5
%372 = icmp ne i8* %371, null
br i1 %372, label %373, label %378
373: ; preds = %370
%374 = load i32, i32* %9
%375 = load i8*, i8** %5
%376 = sext i32 %374 to i64
%377 = getelementptr inbounds i8, i8* %375, i64 %376
store i8* %377, i8** %5
br label %378
378: ; preds = %373, %370
%379 = load i32, i32* %9
%380 = load i32, i32* %10
%381 = add nsw i32 %380, %379
store i32 %381, i32* %10
br label %382
382: ; preds = %378
br label %755
383: ; preds = %36
br label %384
384: ; preds = %383
%385 = load i8*, i8** %5
%386 = call i32 @append_string(i8* %385, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.18, i64 0, i64 0))
store i32 %386, i32* %9
%387 = load i32, i32* %9
%388 = icmp slt i32 %387, 0
br i1 %388, label %389, label %390
389: ; preds = %384
store i32 -1, i32* %3
br label %780
390: ; preds = %384
%391 = load i8*, i8** %5
%392 = icmp ne i8* %391, null
br i1 %392, label %393, label %398
393: ; preds = %390
%394 = load i32, i32* %9
%395 = load i8*, i8** %5
%396 = sext i32 %394 to i64
%397 = getelementptr inbounds i8, i8* %395, i64 %396
store i8* %397, i8** %5
br label %398
398: ; preds = %393, %390
%399 = load i32, i32* %9
%400 = load i32, i32* %10
%401 = add nsw i32 %400, %399
store i32 %401, i32* %10
br label %402
402: ; preds = %398
br label %755
403: ; preds = %36
br label %404
404: ; preds = %403
%405 = load i8*, i8** %5
%406 = call i32 @append_string(i8* %405, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.19, i64 0, i64 0))
store i32 %406, i32* %9
%407 = load i32, i32* %9
%408 = icmp slt i32 %407, 0
br i1 %408, label %409, label %410
409: ; preds = %404
store i32 -1, i32* %3
br label %780
410: ; preds = %404
%411 = load i8*, i8** %5
%412 = icmp ne i8* %411, null
br i1 %412, label %413, label %418
413: ; preds = %410
%414 = load i32, i32* %9
%415 = load i8*, i8** %5
%416 = sext i32 %414 to i64
%417 = getelementptr inbounds i8, i8* %415, i64 %416
store i8* %417, i8** %5
br label %418
418: ; preds = %413, %410
%419 = load i32, i32* %9
%420 = load i32, i32* %10
%421 = add nsw i32 %420, %419
store i32 %421, i32* %10
br label %422
422: ; preds = %418
br label %755
423: ; preds = %36
br label %424
424: ; preds = %423
%425 = load i8*, i8** %5
%426 = call i32 @append_string(i8* %425, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.20, i64 0, i64 0))
store i32 %426, i32* %9
%427 = load i32, i32* %9
%428 = icmp slt i32 %427, 0
br i1 %428, label %429, label %430
429: ; preds = %424
store i32 -1, i32* %3
br label %780
430: ; preds = %424
%431 = load i8*, i8** %5
%432 = icmp ne i8* %431, null
br i1 %432, label %433, label %438
433: ; preds = %430
%434 = load i32, i32* %9
%435 = load i8*, i8** %5
%436 = sext i32 %434 to i64
%437 = getelementptr inbounds i8, i8* %435, i64 %436
store i8* %437, i8** %5
br label %438
438: ; preds = %433, %430
%439 = load i32, i32* %9
%440 = load i32, i32* %10
%441 = add nsw i32 %440, %439
store i32 %441, i32* %10
br label %442
442: ; preds = %438
br label %755
443: ; preds = %36
br label %444
444: ; preds = %443
%445 = load i8*, i8** %5
%446 = call i32 @append_string(i8* %445, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.21, i64 0, i64 0))
store i32 %446, i32* %9
%447 = load i32, i32* %9
%448 = icmp slt i32 %447, 0
br i1 %448, label %449, label %450
449: ; preds = %444
store i32 -1, i32* %3
br label %780
450: ; preds = %444
%451 = load i8*, i8** %5
%452 = icmp ne i8* %451, null
br i1 %452, label %453, label %458
453: ; preds = %450
%454 = load i32, i32* %9
%455 = load i8*, i8** %5
%456 = sext i32 %454 to i64
%457 = getelementptr inbounds i8, i8* %455, i64 %456
store i8* %457, i8** %5
br label %458
458: ; preds = %453, %450
%459 = load i32, i32* %9
%460 = load i32, i32* %10
%461 = add nsw i32 %460, %459
store i32 %461, i32* %10
br label %462
462: ; preds = %458
br label %755
463: ; preds = %36
br label %464
464: ; preds = %463
%465 = load i8*, i8** %5
%466 = call i32 @append_string(i8* %465, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.22, i64 0, i64 0))
store i32 %466, i32* %9
%467 = load i32, i32* %9
%468 = icmp slt i32 %467, 0
br i1 %468, label %469, label %470
469: ; preds = %464
store i32 -1, i32* %3
br label %780
470: ; preds = %464
%471 = load i8*, i8** %5
%472 = icmp ne i8* %471, null
br i1 %472, label %473, label %478
473: ; preds = %470
%474 = load i32, i32* %9
%475 = load i8*, i8** %5
%476 = sext i32 %474 to i64
%477 = getelementptr inbounds i8, i8* %475, i64 %476
store i8* %477, i8** %5
br label %478
478: ; preds = %473, %470
%479 = load i32, i32* %9
%480 = load i32, i32* %10
%481 = add nsw i32 %480, %479
store i32 %481, i32* %10
br label %482
482: ; preds = %478
br label %755
483: ; preds = %36
br label %484
484: ; preds = %483
%485 = load i8*, i8** %5
%486 = call i32 @append_string(i8* %485, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.23, i64 0, i64 0))
store i32 %486, i32* %9
%487 = load i32, i32* %9
%488 = icmp slt i32 %487, 0
br i1 %488, label %489, label %490
489: ; preds = %484
store i32 -1, i32* %3
br label %780
490: ; preds = %484
%491 = load i8*, i8** %5
%492 = icmp ne i8* %491, null
br i1 %492, label %493, label %498
493: ; preds = %490
%494 = load i32, i32* %9
%495 = load i8*, i8** %5
%496 = sext i32 %494 to i64
%497 = getelementptr inbounds i8, i8* %495, i64 %496
store i8* %497, i8** %5
br label %498
498: ; preds = %493, %490
%499 = load i32, i32* %9
%500 = load i32, i32* %10
%501 = add nsw i32 %500, %499
store i32 %501, i32* %10
br label %502
502: ; preds = %498
br label %755
503: ; preds = %36
br label %504
504: ; preds = %503
%505 = load i8*, i8** %5
%506 = call i32 @append_string(i8* %505, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.24, i64 0, i64 0))
store i32 %506, i32* %9
%507 = load i32, i32* %9
%508 = icmp slt i32 %507, 0
br i1 %508, label %509, label %510
509: ; preds = %504
store i32 -1, i32* %3
br label %780
510: ; preds = %504
%511 = load i8*, i8** %5
%512 = icmp ne i8* %511, null
br i1 %512, label %513, label %518
513: ; preds = %510
%514 = load i32, i32* %9
%515 = load i8*, i8** %5
%516 = sext i32 %514 to i64
%517 = getelementptr inbounds i8, i8* %515, i64 %516
store i8* %517, i8** %5
br label %518
518: ; preds = %513, %510
%519 = load i32, i32* %9
%520 = load i32, i32* %10
%521 = add nsw i32 %520, %519
store i32 %521, i32* %10
br label %522
522: ; preds = %518
br label %755
523: ; preds = %36
br label %524
524: ; preds = %523
%525 = load i8*, i8** %5
%526 = call i32 @append_string(i8* %525, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.25, i64 0, i64 0))
store i32 %526, i32* %9
%527 = load i32, i32* %9
%528 = icmp slt i32 %527, 0
br i1 %528, label %529, label %530
529: ; preds = %524
store i32 -1, i32* %3
br label %780
530: ; preds = %524
%531 = load i8*, i8** %5
%532 = icmp ne i8* %531, null
br i1 %532, label %533, label %538
533: ; preds = %530
%534 = load i32, i32* %9
%535 = load i8*, i8** %5
%536 = sext i32 %534 to i64
%537 = getelementptr inbounds i8, i8* %535, i64 %536
store i8* %537, i8** %5
br label %538
538: ; preds = %533, %530
%539 = load i32, i32* %9
%540 = load i32, i32* %10
%541 = add nsw i32 %540, %539
store i32 %541, i32* %10
br label %542
542: ; preds = %538
br label %755
543: ; preds = %36
br label %544
544: ; preds = %543
%545 = load i8*, i8** %5
%546 = call i32 @append_string(i8* %545, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.26, i64 0, i64 0))
store i32 %546, i32* %9
%547 = load i32, i32* %9
%548 = icmp slt i32 %547, 0
br i1 %548, label %549, label %550
549: ; preds = %544
store i32 -1, i32* %3
br label %780
550: ; preds = %544
%551 = load i8*, i8** %5
%552 = icmp ne i8* %551, null
br i1 %552, label %553, label %558
553: ; preds = %550
%554 = load i32, i32* %9
%555 = load i8*, i8** %5
%556 = sext i32 %554 to i64
%557 = getelementptr inbounds i8, i8* %555, i64 %556
store i8* %557, i8** %5
br label %558
558: ; preds = %553, %550
%559 = load i32, i32* %9
%560 = load i32, i32* %10
%561 = add nsw i32 %560, %559
store i32 %561, i32* %10
br label %562
562: ; preds = %558
br label %755
563: ; preds = %36
br label %564
564: ; preds = %563
%565 = load i8*, i8** %5
%566 = call i32 @append_string(i8* %565, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.27, i64 0, i64 0))
store i32 %566, i32* %9
%567 = load i32, i32* %9
%568 = icmp slt i32 %567, 0
br i1 %568, label %569, label %570
569: ; preds = %564
store i32 -1, i32* %3
br label %780
570: ; preds = %564
%571 = load i8*, i8** %5
%572 = icmp ne i8* %571, null
br i1 %572, label %573, label %578
573: ; preds = %570
%574 = load i32, i32* %9
%575 = load i8*, i8** %5
%576 = sext i32 %574 to i64
%577 = getelementptr inbounds i8, i8* %575, i64 %576
store i8* %577, i8** %5
br label %578
578: ; preds = %573, %570
%579 = load i32, i32* %9
%580 = load i32, i32* %10
%581 = add nsw i32 %580, %579
store i32 %581, i32* %10
br label %582
582: ; preds = %578
br label %755
583: ; preds = %36
br label %584
584: ; preds = %583
%585 = load i8*, i8** %5
%586 = call i32 @append_string(i8* %585, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.28, i64 0, i64 0))
store i32 %586, i32* %9
%587 = load i32, i32* %9
%588 = icmp slt i32 %587, 0
br i1 %588, label %589, label %590
589: ; preds = %584
store i32 -1, i32* %3
br label %780
590: ; preds = %584
%591 = load i8*, i8** %5
%592 = icmp ne i8* %591, null
br i1 %592, label %593, label %598
593: ; preds = %590
%594 = load i32, i32* %9
%595 = load i8*, i8** %5
%596 = sext i32 %594 to i64
%597 = getelementptr inbounds i8, i8* %595, i64 %596
store i8* %597, i8** %5
br label %598
598: ; preds = %593, %590
%599 = load i32, i32* %9
%600 = load i32, i32* %10
%601 = add nsw i32 %600, %599
store i32 %601, i32* %10
br label %602
602: ; preds = %598
br label %755
603: ; preds = %36
br label %604
604: ; preds = %603
%605 = load i8*, i8** %5
%606 = call i32 @append_string(i8* %605, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.29, i64 0, i64 0))
store i32 %606, i32* %9
%607 = load i32, i32* %9
%608 = icmp slt i32 %607, 0
br i1 %608, label %609, label %610
609: ; preds = %604
store i32 -1, i32* %3
br label %780
610: ; preds = %604
%611 = load i8*, i8** %5
%612 = icmp ne i8* %611, null
br i1 %612, label %613, label %618
613: ; preds = %610
%614 = load i32, i32* %9
%615 = load i8*, i8** %5
%616 = sext i32 %614 to i64
%617 = getelementptr inbounds i8, i8* %615, i64 %616
store i8* %617, i8** %5
br label %618
618: ; preds = %613, %610
%619 = load i32, i32* %9
%620 = load i32, i32* %10
%621 = add nsw i32 %620, %619
store i32 %621, i32* %10
br label %622
622: ; preds = %618
br label %755
623: ; preds = %36
br label %624
624: ; preds = %623
%625 = load i8*, i8** %5
%626 = call i32 @append_string(i8* %625, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.30, i64 0, i64 0))
store i32 %626, i32* %9
%627 = load i32, i32* %9
%628 = icmp slt i32 %627, 0
br i1 %628, label %629, label %630
629: ; preds = %624
store i32 -1, i32* %3
br label %780
630: ; preds = %624
%631 = load i8*, i8** %5
%632 = icmp ne i8* %631, null
br i1 %632, label %633, label %638
633: ; preds = %630
%634 = load i32, i32* %9
%635 = load i8*, i8** %5
%636 = sext i32 %634 to i64
%637 = getelementptr inbounds i8, i8* %635, i64 %636
store i8* %637, i8** %5
br label %638
638: ; preds = %633, %630
%639 = load i32, i32* %9
%640 = load i32, i32* %10
%641 = add nsw i32 %640, %639
store i32 %641, i32* %10
br label %642
642: ; preds = %638
br label %755
643: ; preds = %36
br label %644
644: ; preds = %643
%645 = load i8*, i8** %5
%646 = call i32 @append_string(i8* %645, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.31, i64 0, i64 0))
store i32 %646, i32* %9
%647 = load i32, i32* %9
%648 = icmp slt i32 %647, 0
br i1 %648, label %649, label %650
649: ; preds = %644
store i32 -1, i32* %3
br label %780
650: ; preds = %644
%651 = load i8*, i8** %5
%652 = icmp ne i8* %651, null
br i1 %652, label %653, label %658
653: ; preds = %650
%654 = load i32, i32* %9
%655 = load i8*, i8** %5
%656 = sext i32 %654 to i64
%657 = getelementptr inbounds i8, i8* %655, i64 %656
store i8* %657, i8** %5
br label %658
658: ; preds = %653, %650
%659 = load i32, i32* %9
%660 = load i32, i32* %10
%661 = add nsw i32 %660, %659
store i32 %661, i32* %10
br label %662
662: ; preds = %658
br label %755
663: ; preds = %36
br label %664
664: ; preds = %663
%665 = load i8*, i8** %5
%666 = call i32 @append_string(i8* %665, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.32, i64 0, i64 0))
store i32 %666, i32* %9
%667 = load i32, i32* %9
%668 = icmp slt i32 %667, 0
br i1 %668, label %669, label %670
669: ; preds = %664
store i32 -1, i32* %3
br label %780
670: ; preds = %664
%671 = load i8*, i8** %5
%672 = icmp ne i8* %671, null
br i1 %672, label %673, label %678
673: ; preds = %670
%674 = load i32, i32* %9
%675 = load i8*, i8** %5
%676 = sext i32 %674 to i64
%677 = getelementptr inbounds i8, i8* %675, i64 %676
store i8* %677, i8** %5
br label %678
678: ; preds = %673, %670
%679 = load i32, i32* %9
%680 = load i32, i32* %10
%681 = add nsw i32 %680, %679
store i32 %681, i32* %10
br label %682
682: ; preds = %678
br label %755
683: ; preds = %36
br label %684
684: ; preds = %683
%685 = load i8*, i8** %5
%686 = call i32 @append_string(i8* %685, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.33, i64 0, i64 0))
store i32 %686, i32* %9
%687 = load i32, i32* %9
%688 = icmp slt i32 %687, 0
br i1 %688, label %689, label %690
689: ; preds = %684
store i32 -1, i32* %3
br label %780
690: ; preds = %684
%691 = load i8*, i8** %5
%692 = icmp ne i8* %691, null
br i1 %692, label %693, label %698
693: ; preds = %690
%694 = load i32, i32* %9
%695 = load i8*, i8** %5
%696 = sext i32 %694 to i64
%697 = getelementptr inbounds i8, i8* %695, i64 %696
store i8* %697, i8** %5
br label %698
698: ; preds = %693, %690
%699 = load i32, i32* %9
%700 = load i32, i32* %10
%701 = add nsw i32 %700, %699
store i32 %701, i32* %10
br label %702
702: ; preds = %698
br label %755
703: ; preds = %36
br label %704
704: ; preds = %703
%705 = load i8*, i8** %5
%706 = call i32 @append_string(i8* %705, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.34, i64 0, i64 0))
store i32 %706, i32* %9
%707 = load i32, i32* %9
%708 = icmp slt i32 %707, 0
br i1 %708, label %709, label %710
709: ; preds = %704
store i32 -1, i32* %3
br label %780
710: ; preds = %704
%711 = load i8*, i8** %5
%712 = icmp ne i8* %711, null
br i1 %712, label %713, label %718
713: ; preds = %710
%714 = load i32, i32* %9
%715 = load i8*, i8** %5
%716 = sext i32 %714 to i64
%717 = getelementptr inbounds i8, i8* %715, i64 %716
store i8* %717, i8** %5
br label %718
718: ; preds = %713, %710
%719 = load i32, i32* %9
%720 = load i32, i32* %10
%721 = add nsw i32 %720, %719
store i32 %721, i32* %10
br label %722
722: ; preds = %718
br label %755
723: ; preds = %36
br label %724
724: ; preds = %723
%725 = load i8*, i8** %5
%726 = call i32 @append_string(i8* %725, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.35, i64 0, i64 0))
store i32 %726, i32* %9
%727 = load i32, i32* %9
%728 = icmp slt i32 %727, 0
br i1 %728, label %729, label %730
729: ; preds = %724
store i32 -1, i32* %3
br label %780
730: ; preds = %724
%731 = load i8*, i8** %5
%732 = icmp ne i8* %731, null
br i1 %732, label %733, label %738
733: ; preds = %730
%734 = load i32, i32* %9
%735 = load i8*, i8** %5
%736 = sext i32 %734 to i64
%737 = getelementptr inbounds i8, i8* %735, i64 %736
store i8* %737, i8** %5
br label %738
738: ; preds = %733, %730
%739 = load i32, i32* %9
%740 = load i32, i32* %10
%741 = add nsw i32 %740, %739
store i32 %741, i32* %10
br label %742
742: ; preds = %738
br label %755
743: ; preds = %36
%744 = load i8*, i8** %5
%745 = icmp ne i8* %744, null
br i1 %745, label %746, label %752
746: ; preds = %743
%747 = load i8, i8* %8
%748 = load i8*, i8** %5
%749 = getelementptr inbounds i8, i8* %748, i64 0
store i8 %747, i8* %749
%750 = load i8*, i8** %5
%751 = getelementptr inbounds i8, i8* %750, i64 1
store i8* %751, i8** %5
br label %752
752: ; preds = %746, %743
%753 = load i32, i32* %10
%754 = add nsw i32 %753, 1
store i32 %754, i32* %10
br label %755
755: ; preds = %752, %742, %722, %702, %682, %662, %642, %622, %602, %582, %562, %542, %522, %502, %482, %462, %442, %422, %402, %382, %362, %342, %322, %302, %282, %262, %242, %222, %202, %182, %162, %142, %122, %102, %82, %62
br label %756
756: ; preds = %755
%757 = load i64, i64* %6
%758 = add i64 %757, 1
store i64 %758, i64* %6
br label %32
759: ; preds = %32
br label %760
760: ; preds = %759
%761 = load i8*, i8** %5
%762 = call i32 @append_string(i8* %761, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
store i32 %762, i32* %9
%763 = load i32, i32* %9
%764 = icmp slt i32 %763, 0
br i1 %764, label %765, label %766
765: ; preds = %760
store i32 -1, i32* %3
br label %780
766: ; preds = %760
%767 = load i8*, i8** %5
%768 = icmp ne i8* %767, null
br i1 %768, label %769, label %774
769: ; preds = %766
%770 = load i32, i32* %9
%771 = load i8*, i8** %5
%772 = sext i32 %770 to i64
%773 = getelementptr inbounds i8, i8* %771, i64 %772
store i8* %773, i8** %5
br label %774
774: ; preds = %769, %766
%775 = load i32, i32* %9
%776 = load i32, i32* %10
%777 = add nsw i32 %776, %775
store i32 %777, i32* %10
br label %778
778: ; preds = %774
%779 = load i32, i32* %10
store i32 %779, i32* %3
br label %780
780: ; preds = %778, %765, %729, %709, %689, %669, %649, %629, %609, %589, %569, %549, %529, %509, %489, %469, %449, %429, %409, %389, %369, %349, %329, %309, %289, %269, %249, %229, %209, %189, %169, %149, %129, %109, %89, %69, %49, %18
%781 = load i32, i32* %3
ret i32 %781
}

LLVM IR (-O2):
@.str = [2 x i8] c"\22\00"
@.str.1 = [3 x i8] c"\\\22\00"
@.str.2 = [3 x i8] c"\\\\\00"
@.str.3 = [3 x i8] c"\\/\00"
@.str.4 = [3 x i8] c"\\b\00"
@.str.5 = [3 x i8] c"\\f\00"
@.str.6 = [3 x i8] c"\\n\00"
@.str.7 = [3 x i8] c"\\r\00"
@.str.8 = [3 x i8] c"\\t\00"
@.str.9 = [7 x i8] c"\\u0000\00"
@.str.10 = [7 x i8] c"\\u0001\00"
@.str.11 = [7 x i8] c"\\u0002\00"
@.str.12 = [7 x i8] c"\\u0003\00"
@.str.13 = [7 x i8] c"\\u0004\00"
@.str.14 = [7 x i8] c"\\u0005\00"
@.str.15 = [7 x i8] c"\\u0006\00"
@.str.16 = [7 x i8] c"\\u0007\00"
@.str.17 = [7 x i8] c"\\u000b\00"
@.str.18 = [7 x i8] c"\\u000e\00"
@.str.19 = [7 x i8] c"\\u000f\00"
@.str.20 = [7 x i8] c"\\u0010\00"
@.str.21 = [7 x i8] c"\\u0011\00"
@.str.22 = [7 x i8] c"\\u0012\00"
@.str.23 = [7 x i8] c"\\u0013\00"
@.str.24 = [7 x i8] c"\\u0014\00"
@.str.25 = [7 x i8] c"\\u0015\00"
@.str.26 = [7 x i8] c"\\u0016\00"
@.str.27 = [7 x i8] c"\\u0017\00"
@.str.28 = [7 x i8] c"\\u0018\00"
@.str.29 = [7 x i8] c"\\u0019\00"
@.str.30 = [7 x i8] c"\\u001a\00"
@.str.31 = [7 x i8] c"\\u001b\00"
@.str.32 = [7 x i8] c"\\u001c\00"
@.str.33 = [7 x i8] c"\\u001d\00"
@.str.34 = [7 x i8] c"\\u001e\00"
@.str.35 = [7 x i8] c"\\u001f\00"
define i32 @json_serialize_string(i8* nocapture %0, i8* %1) {
%3 = tail call i64 @strlen(i8* dereferenceable(1) %0)
%4 = tail call i32 @append_string(i8* %1, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%5 = icmp slt i32 %4, 0
br i1 %5, label %353, label %6
6: ; preds = %2
%7 = icmp eq i8* %1, null
%8 = zext i32 %4 to i64
%9 = getelementptr inbounds i8, i8* %1, i64 %8
%10 = select i1 %7, i8* null, i8* %9
%11 = icmp eq i64 %3, 0
br i1 %11, label %346, label %12
12: ; preds = %6, %341
%13 = phi i32 [ %343, %341 ], [ %4, %6 ]
%14 = phi i64 [ %344, %341 ], [ 0, %6 ]
%15 = phi i8* [ %342, %341 ], [ %10, %6 ]
%16 = getelementptr inbounds i8, i8* %0, i64 %14
%17 = load i8, i8* %16
%18 = sext i8 %17 to i32
switch i32 %18, label %334 [
i32 34, label %19
i32 92, label %28
i32 47, label %37
i32 8, label %46
i32 12, label %55
i32 10, label %64
i32 13, label %73
i32 9, label %82
i32 0, label %91
i32 1, label %100
i32 2, label %109
i32 3, label %118
i32 4, label %127
i32 5, label %136
i32 6, label %145
i32 7, label %154
i32 11, label %163
i32 14, label %172
i32 15, label %181
i32 16, label %190
i32 17, label %199
i32 18, label %208
i32 19, label %217
i32 20, label %226
i32 21, label %235
i32 22, label %244
i32 23, label %253
i32 24, label %262
i32 25, label %271
i32 26, label %280
i32 27, label %289
i32 28, label %298
i32 29, label %307
i32 30, label %316
i32 31, label %325
]
19: ; preds = %12
%20 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%21 = icmp slt i32 %20, 0
br i1 %21, label %353, label %22
22: ; preds = %19
%23 = icmp eq i8* %15, null
%24 = zext i32 %20 to i64
%25 = getelementptr inbounds i8, i8* %15, i64 %24
%26 = select i1 %23, i8* null, i8* %25
%27 = add nsw i32 %20, %13
br label %341
28: ; preds = %12
%29 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%30 = icmp slt i32 %29, 0
br i1 %30, label %353, label %31
31: ; preds = %28
%32 = icmp eq i8* %15, null
%33 = zext i32 %29 to i64
%34 = getelementptr inbounds i8, i8* %15, i64 %33
%35 = select i1 %32, i8* null, i8* %34
%36 = add nsw i32 %29, %13
br label %341
37: ; preds = %12
%38 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0))
%39 = icmp slt i32 %38, 0
br i1 %39, label %353, label %40
40: ; preds = %37
%41 = icmp eq i8* %15, null
%42 = zext i32 %38 to i64
%43 = getelementptr inbounds i8, i8* %15, i64 %42
%44 = select i1 %41, i8* null, i8* %43
%45 = add nsw i32 %38, %13
br label %341
46: ; preds = %12
%47 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0))
%48 = icmp slt i32 %47, 0
br i1 %48, label %353, label %49
49: ; preds = %46
%50 = icmp eq i8* %15, null
%51 = zext i32 %47 to i64
%52 = getelementptr inbounds i8, i8* %15, i64 %51
%53 = select i1 %50, i8* null, i8* %52
%54 = add nsw i32 %47, %13
br label %341
55: ; preds = %12
%56 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0))
%57 = icmp slt i32 %56, 0
br i1 %57, label %353, label %58
58: ; preds = %55
%59 = icmp eq i8* %15, null
%60 = zext i32 %56 to i64
%61 = getelementptr inbounds i8, i8* %15, i64 %60
%62 = select i1 %59, i8* null, i8* %61
%63 = add nsw i32 %56, %13
br label %341
64: ; preds = %12
%65 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
%66 = icmp slt i32 %65, 0
br i1 %66, label %353, label %67
67: ; preds = %64
%68 = icmp eq i8* %15, null
%69 = zext i32 %65 to i64
%70 = getelementptr inbounds i8, i8* %15, i64 %69
%71 = select i1 %68, i8* null, i8* %70
%72 = add nsw i32 %65, %13
br label %341
73: ; preds = %12
%74 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i64 0, i64 0))
%75 = icmp slt i32 %74, 0
br i1 %75, label %353, label %76
76: ; preds = %73
%77 = icmp eq i8* %15, null
%78 = zext i32 %74 to i64
%79 = getelementptr inbounds i8, i8* %15, i64 %78
%80 = select i1 %77, i8* null, i8* %79
%81 = add nsw i32 %74, %13
br label %341
82: ; preds = %12
%83 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0))
%84 = icmp slt i32 %83, 0
br i1 %84, label %353, label %85
85: ; preds = %82
%86 = icmp eq i8* %15, null
%87 = zext i32 %83 to i64
%88 = getelementptr inbounds i8, i8* %15, i64 %87
%89 = select i1 %86, i8* null, i8* %88
%90 = add nsw i32 %83, %13
br label %341
91: ; preds = %12
%92 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.9, i64 0, i64 0))
%93 = icmp slt i32 %92, 0
br i1 %93, label %353, label %94
94: ; preds = %91
%95 = icmp eq i8* %15, null
%96 = zext i32 %92 to i64
%97 = getelementptr inbounds i8, i8* %15, i64 %96
%98 = select i1 %95, i8* null, i8* %97
%99 = add nsw i32 %92, %13
br label %341
100: ; preds = %12
%101 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.10, i64 0, i64 0))
%102 = icmp slt i32 %101, 0
br i1 %102, label %353, label %103
103: ; preds = %100
%104 = icmp eq i8* %15, null
%105 = zext i32 %101 to i64
%106 = getelementptr inbounds i8, i8* %15, i64 %105
%107 = select i1 %104, i8* null, i8* %106
%108 = add nsw i32 %101, %13
br label %341
109: ; preds = %12
%110 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.11, i64 0, i64 0))
%111 = icmp slt i32 %110, 0
br i1 %111, label %353, label %112
112: ; preds = %109
%113 = icmp eq i8* %15, null
%114 = zext i32 %110 to i64
%115 = getelementptr inbounds i8, i8* %15, i64 %114
%116 = select i1 %113, i8* null, i8* %115
%117 = add nsw i32 %110, %13
br label %341
118: ; preds = %12
%119 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.12, i64 0, i64 0))
%120 = icmp slt i32 %119, 0
br i1 %120, label %353, label %121
121: ; preds = %118
%122 = icmp eq i8* %15, null
%123 = zext i32 %119 to i64
%124 = getelementptr inbounds i8, i8* %15, i64 %123
%125 = select i1 %122, i8* null, i8* %124
%126 = add nsw i32 %119, %13
br label %341
127: ; preds = %12
%128 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.13, i64 0, i64 0))
%129 = icmp slt i32 %128, 0
br i1 %129, label %353, label %130
130: ; preds = %127
%131 = icmp eq i8* %15, null
%132 = zext i32 %128 to i64
%133 = getelementptr inbounds i8, i8* %15, i64 %132
%134 = select i1 %131, i8* null, i8* %133
%135 = add nsw i32 %128, %13
br label %341
136: ; preds = %12
%137 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.14, i64 0, i64 0))
%138 = icmp slt i32 %137, 0
br i1 %138, label %353, label %139
139: ; preds = %136
%140 = icmp eq i8* %15, null
%141 = zext i32 %137 to i64
%142 = getelementptr inbounds i8, i8* %15, i64 %141
%143 = select i1 %140, i8* null, i8* %142
%144 = add nsw i32 %137, %13
br label %341
145: ; preds = %12
%146 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.15, i64 0, i64 0))
%147 = icmp slt i32 %146, 0
br i1 %147, label %353, label %148
148: ; preds = %145
%149 = icmp eq i8* %15, null
%150 = zext i32 %146 to i64
%151 = getelementptr inbounds i8, i8* %15, i64 %150
%152 = select i1 %149, i8* null, i8* %151
%153 = add nsw i32 %146, %13
br label %341
154: ; preds = %12
%155 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.16, i64 0, i64 0))
%156 = icmp slt i32 %155, 0
br i1 %156, label %353, label %157
157: ; preds = %154
%158 = icmp eq i8* %15, null
%159 = zext i32 %155 to i64
%160 = getelementptr inbounds i8, i8* %15, i64 %159
%161 = select i1 %158, i8* null, i8* %160
%162 = add nsw i32 %155, %13
br label %341
163: ; preds = %12
%164 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.17, i64 0, i64 0))
%165 = icmp slt i32 %164, 0
br i1 %165, label %353, label %166
166: ; preds = %163
%167 = icmp eq i8* %15, null
%168 = zext i32 %164 to i64
%169 = getelementptr inbounds i8, i8* %15, i64 %168
%170 = select i1 %167, i8* null, i8* %169
%171 = add nsw i32 %164, %13
br label %341
172: ; preds = %12
%173 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.18, i64 0, i64 0))
%174 = icmp slt i32 %173, 0
br i1 %174, label %353, label %175
175: ; preds = %172
%176 = icmp eq i8* %15, null
%177 = zext i32 %173 to i64
%178 = getelementptr inbounds i8, i8* %15, i64 %177
%179 = select i1 %176, i8* null, i8* %178
%180 = add nsw i32 %173, %13
br label %341
181: ; preds = %12
%182 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.19, i64 0, i64 0))
%183 = icmp slt i32 %182, 0
br i1 %183, label %353, label %184
184: ; preds = %181
%185 = icmp eq i8* %15, null
%186 = zext i32 %182 to i64
%187 = getelementptr inbounds i8, i8* %15, i64 %186
%188 = select i1 %185, i8* null, i8* %187
%189 = add nsw i32 %182, %13
br label %341
190: ; preds = %12
%191 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.20, i64 0, i64 0))
%192 = icmp slt i32 %191, 0
br i1 %192, label %353, label %193
193: ; preds = %190
%194 = icmp eq i8* %15, null
%195 = zext i32 %191 to i64
%196 = getelementptr inbounds i8, i8* %15, i64 %195
%197 = select i1 %194, i8* null, i8* %196
%198 = add nsw i32 %191, %13
br label %341
199: ; preds = %12
%200 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.21, i64 0, i64 0))
%201 = icmp slt i32 %200, 0
br i1 %201, label %353, label %202
202: ; preds = %199
%203 = icmp eq i8* %15, null
%204 = zext i32 %200 to i64
%205 = getelementptr inbounds i8, i8* %15, i64 %204
%206 = select i1 %203, i8* null, i8* %205
%207 = add nsw i32 %200, %13
br label %341
208: ; preds = %12
%209 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.22, i64 0, i64 0))
%210 = icmp slt i32 %209, 0
br i1 %210, label %353, label %211
211: ; preds = %208
%212 = icmp eq i8* %15, null
%213 = zext i32 %209 to i64
%214 = getelementptr inbounds i8, i8* %15, i64 %213
%215 = select i1 %212, i8* null, i8* %214
%216 = add nsw i32 %209, %13
br label %341
217: ; preds = %12
%218 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.23, i64 0, i64 0))
%219 = icmp slt i32 %218, 0
br i1 %219, label %353, label %220
220: ; preds = %217
%221 = icmp eq i8* %15, null
%222 = zext i32 %218 to i64
%223 = getelementptr inbounds i8, i8* %15, i64 %222
%224 = select i1 %221, i8* null, i8* %223
%225 = add nsw i32 %218, %13
br label %341
226: ; preds = %12
%227 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.24, i64 0, i64 0))
%228 = icmp slt i32 %227, 0
br i1 %228, label %353, label %229
229: ; preds = %226
%230 = icmp eq i8* %15, null
%231 = zext i32 %227 to i64
%232 = getelementptr inbounds i8, i8* %15, i64 %231
%233 = select i1 %230, i8* null, i8* %232
%234 = add nsw i32 %227, %13
br label %341
235: ; preds = %12
%236 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.25, i64 0, i64 0))
%237 = icmp slt i32 %236, 0
br i1 %237, label %353, label %238
238: ; preds = %235
%239 = icmp eq i8* %15, null
%240 = zext i32 %236 to i64
%241 = getelementptr inbounds i8, i8* %15, i64 %240
%242 = select i1 %239, i8* null, i8* %241
%243 = add nsw i32 %236, %13
br label %341
244: ; preds = %12
%245 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.26, i64 0, i64 0))
%246 = icmp slt i32 %245, 0
br i1 %246, label %353, label %247
247: ; preds = %244
%248 = icmp eq i8* %15, null
%249 = zext i32 %245 to i64
%250 = getelementptr inbounds i8, i8* %15, i64 %249
%251 = select i1 %248, i8* null, i8* %250
%252 = add nsw i32 %245, %13
br label %341
253: ; preds = %12
%254 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.27, i64 0, i64 0))
%255 = icmp slt i32 %254, 0
br i1 %255, label %353, label %256
256: ; preds = %253
%257 = icmp eq i8* %15, null
%258 = zext i32 %254 to i64
%259 = getelementptr inbounds i8, i8* %15, i64 %258
%260 = select i1 %257, i8* null, i8* %259
%261 = add nsw i32 %254, %13
br label %341
262: ; preds = %12
%263 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.28, i64 0, i64 0))
%264 = icmp slt i32 %263, 0
br i1 %264, label %353, label %265
265: ; preds = %262
%266 = icmp eq i8* %15, null
%267 = zext i32 %263 to i64
%268 = getelementptr inbounds i8, i8* %15, i64 %267
%269 = select i1 %266, i8* null, i8* %268
%270 = add nsw i32 %263, %13
br label %341
271: ; preds = %12
%272 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.29, i64 0, i64 0))
%273 = icmp slt i32 %272, 0
br i1 %273, label %353, label %274
274: ; preds = %271
%275 = icmp eq i8* %15, null
%276 = zext i32 %272 to i64
%277 = getelementptr inbounds i8, i8* %15, i64 %276
%278 = select i1 %275, i8* null, i8* %277
%279 = add nsw i32 %272, %13
br label %341
280: ; preds = %12
%281 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.30, i64 0, i64 0))
%282 = icmp slt i32 %281, 0
br i1 %282, label %353, label %283
283: ; preds = %280
%284 = icmp eq i8* %15, null
%285 = zext i32 %281 to i64
%286 = getelementptr inbounds i8, i8* %15, i64 %285
%287 = select i1 %284, i8* null, i8* %286
%288 = add nsw i32 %281, %13
br label %341
289: ; preds = %12
%290 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.31, i64 0, i64 0))
%291 = icmp slt i32 %290, 0
br i1 %291, label %353, label %292
292: ; preds = %289
%293 = icmp eq i8* %15, null
%294 = zext i32 %290 to i64
%295 = getelementptr inbounds i8, i8* %15, i64 %294
%296 = select i1 %293, i8* null, i8* %295
%297 = add nsw i32 %290, %13
br label %341
298: ; preds = %12
%299 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.32, i64 0, i64 0))
%300 = icmp slt i32 %299, 0
br i1 %300, label %353, label %301
301: ; preds = %298
%302 = icmp eq i8* %15, null
%303 = zext i32 %299 to i64
%304 = getelementptr inbounds i8, i8* %15, i64 %303
%305 = select i1 %302, i8* null, i8* %304
%306 = add nsw i32 %299, %13
br label %341
307: ; preds = %12
%308 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.33, i64 0, i64 0))
%309 = icmp slt i32 %308, 0
br i1 %309, label %353, label %310
310: ; preds = %307
%311 = icmp eq i8* %15, null
%312 = zext i32 %308 to i64
%313 = getelementptr inbounds i8, i8* %15, i64 %312
%314 = select i1 %311, i8* null, i8* %313
%315 = add nsw i32 %308, %13
br label %341
316: ; preds = %12
%317 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.34, i64 0, i64 0))
%318 = icmp slt i32 %317, 0
br i1 %318, label %353, label %319
319: ; preds = %316
%320 = icmp eq i8* %15, null
%321 = zext i32 %317 to i64
%322 = getelementptr inbounds i8, i8* %15, i64 %321
%323 = select i1 %320, i8* null, i8* %322
%324 = add nsw i32 %317, %13
br label %341
325: ; preds = %12
%326 = tail call i32 @append_string(i8* %15, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.35, i64 0, i64 0))
%327 = icmp slt i32 %326, 0
br i1 %327, label %353, label %328
328: ; preds = %325
%329 = icmp eq i8* %15, null
%330 = zext i32 %326 to i64
%331 = getelementptr inbounds i8, i8* %15, i64 %330
%332 = select i1 %329, i8* null, i8* %331
%333 = add nsw i32 %326, %13
br label %341
334: ; preds = %12
%335 = icmp eq i8* %15, null
br i1 %335, label %338, label %336
336: ; preds = %334
store i8 %17, i8* %15
%337 = getelementptr inbounds i8, i8* %15, i64 1
br label %338
338: ; preds = %336, %334
%339 = phi i8* [ %337, %336 ], [ null, %334 ]
%340 = add nsw i32 %13, 1
br label %341
341: ; preds = %22, %31, %40, %49, %58, %67, %76, %85, %94, %103, %112, %121, %130, %139, %148, %157, %166, %175, %184, %193, %202, %211, %220, %229, %238, %247, %256, %265, %274, %283, %292, %301, %310, %319, %328, %338
%342 = phi i8* [ %339, %338 ], [ %332, %328 ], [ %323, %319 ], [ %314, %310 ], [ %305, %301 ], [ %296, %292 ], [ %287, %283 ], [ %278, %274 ], [ %269, %265 ], [ %260, %256 ], [ %251, %247 ], [ %242, %238 ], [ %233, %229 ], [ %224, %220 ], [ %215, %211 ], [ %206, %202 ], [ %197, %193 ], [ %188, %184 ], [ %179, %175 ], [ %170, %166 ], [ %161, %157 ], [ %152, %148 ], [ %143, %139 ], [ %134, %130 ], [ %125, %121 ], [ %116, %112 ], [ %107, %103 ], [ %98, %94 ], [ %89, %85 ], [ %80, %76 ], [ %71, %67 ], [ %62, %58 ], [ %53, %49 ], [ %44, %40 ], [ %35, %31 ], [ %26, %22 ]
%343 = phi i32 [ %340, %338 ], [ %333, %328 ], [ %324, %319 ], [ %315, %310 ], [ %306, %301 ], [ %297, %292 ], [ %288, %283 ], [ %279, %274 ], [ %270, %265 ], [ %261, %256 ], [ %252, %247 ], [ %243, %238 ], [ %234, %229 ], [ %225, %220 ], [ %216, %211 ], [ %207, %202 ], [ %198, %193 ], [ %189, %184 ], [ %180, %175 ], [ %171, %166 ], [ %162, %157 ], [ %153, %148 ], [ %144, %139 ], [ %135, %130 ], [ %126, %121 ], [ %117, %112 ], [ %108, %103 ], [ %99, %94 ], [ %90, %85 ], [ %81, %76 ], [ %72, %67 ], [ %63, %58 ], [ %54, %49 ], [ %45, %40 ], [ %36, %31 ], [ %27, %22 ]
%344 = add nuw i64 %14, 1
%345 = icmp eq i64 %344, %3
br i1 %345, label %346, label %12
346: ; preds = %341, %6
%347 = phi i8* [ %10, %6 ], [ %342, %341 ]
%348 = phi i32 [ %4, %6 ], [ %343, %341 ]
%349 = tail call i32 @append_string(i8* %347, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%350 = add nsw i32 %349, %348
%351 = icmp sgt i32 %349, -1
%352 = select i1 %351, i32 %350, i32 -1
br label %353
353: ; preds = %325, %316, %307, %298, %289, %280, %271, %262, %253, %244, %235, %226, %217, %208, %199, %190, %181, %172, %163, %154, %145, %136, %127, %118, %109, %100, %91, %82, %73, %64, %55, %46, %37, %28, %19, %346, %2
%354 = phi i32 [ -1, %2 ], [ %352, %346 ], [ -1, %19 ], [ -1, %28 ], [ -1, %37 ], [ -1, %46 ], [ -1, %55 ], [ -1, %64 ], [ -1, %73 ], [ -1, %82 ], [ -1, %91 ], [ -1, %100 ], [ -1, %109 ], [ -1, %118 ], [ -1, %127 ], [ -1, %136 ], [ -1, %145 ], [ -1, %154 ], [ -1, %163 ], [ -1, %172 ], [ -1, %181 ], [ -1, %190 ], [ -1, %199 ], [ -1, %208 ], [ -1, %217 ], [ -1, %226 ], [ -1, %235 ], [ -1, %244 ], [ -1, %253 ], [ -1, %262 ], [ -1, %271 ], [ -1, %280 ], [ -1, %289 ], [ -1, %298 ], [ -1, %307 ], [ -1, %316 ], [ -1, %325 ]
ret i32 %354
}