#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 /*<<< orphan*/ isxdigit(unsigned char const);
char *malloc(int);
int /*<<< orphan*/ memcpy(char *, char *, int);
int strlen(char const *);
int /*<<< orphan*/ utf8_int_string(unsigned int, char *);
char *string_convert_escaped_chars(const char *string) {
  const unsigned char *ptr_string;
  char *output, utf_char[16];
  int pos_output, i, length;
  unsigned int value;
  if (!string)
    return NULL;
  output = malloc(strlen(string) + 1);
  if (!output)
    return NULL;
  pos_output = 0;
  ptr_string = (const unsigned char *)string;
  while (ptr_string && ptr_string[0]) {
    if (ptr_string[0] == '\\') {
      ptr_string++;
      switch (ptr_string[0]) {
      case '"':
        output[pos_output++] = '"';
        ptr_string++;
        break;
      case '\\':
        output[pos_output++] = '\\';
        ptr_string++;
        break;
      case 'a':
        output[pos_output++] = 7;
        ptr_string++;
        break;
      case 'b':
        output[pos_output++] = 8;
        ptr_string++;
        break;
      case 'e':
        output[pos_output++] = 27;
        ptr_string++;
        break;
      case 'f':
        output[pos_output++] = 12;
        ptr_string++;
        break;
      case 'n':
        output[pos_output++] = 10;
        ptr_string++;
        break;
      case 'r':
        output[pos_output++] = 13;
        ptr_string++;
        break;
      case 't':
        output[pos_output++] = 9;
        ptr_string++;
        break;
      case 'v':
        output[pos_output++] = 11;
        ptr_string++;
        break;
      case '0':
        value = 0;
        for (i = 0; (i < 3) &&
                    ((ptr_string[i + 1] >= '0') && (ptr_string[i + 1] <= '7'));
             i++) {
          value = (value * 8) + (ptr_string[i + 1] - '0');
        }
        output[pos_output++] = value;
        ptr_string += 1 + i;
        break;
      case 'x':
      case 'X':
        if (isxdigit(ptr_string[1])) {
          value = 0;
          for (i = 0; (i < 2) && isxdigit(ptr_string[i + 1]); i++) {
            value =
                (value * 16) +
                (((ptr_string[i + 1] >= 'a') && (ptr_string[i + 1] <= 'f'))
                     ? ptr_string[i + 1] - 'a' + 10
                 : ((ptr_string[i + 1] >= 'A') && (ptr_string[i + 1] <= 'F'))
                     ? ptr_string[i + 1] - 'A' + 10
                     : ptr_string[i + 1] - '0');
          }
          output[pos_output++] = value;
          ptr_string += 1 + i;
        } else {
          output[pos_output++] = ptr_string[0];
          ptr_string++;
        }
        break;
      case 'u':
      case 'U':
        if (isxdigit(ptr_string[1])) {
          value = 0;
          for (i = 0; (i < ((ptr_string[0] == 'u') ? 4 : 8)) &&
                      isxdigit(ptr_string[i + 1]);
               i++) {
            value =
                (value * 16) +
                (((ptr_string[i + 1] >= 'a') && (ptr_string[i + 1] <= 'f'))
                     ? ptr_string[i + 1] - 'a' + 10
                 : ((ptr_string[i + 1] >= 'A') && (ptr_string[i + 1] <= 'F'))
                     ? ptr_string[i + 1] - 'A' + 10
                     : ptr_string[i + 1] - '0');
          }
          utf8_int_string(value, utf_char);
          if (utf_char[0]) {
            length = strlen(utf_char);
            memcpy(output + pos_output, utf_char, length);
            pos_output += length;
          }
          ptr_string += 1 + i;
        } else {
          output[pos_output++] = ptr_string[0];
          ptr_string++;
        }
        break;
      default:
        if (ptr_string[0]) {
          output[pos_output++] = '\\';
          output[pos_output++] = ptr_string[0];
          ptr_string++;
        }
        break;
      }
    } else {
      output[pos_output++] = ptr_string[0];
      ptr_string++;
    }
  }
  output[pos_output] = '\0';
  return output;
}


x86 assembly (clang, -O0):
<string_convert_escaped_chars>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x10(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    1174 <string_convert_escaped_chars+0x24>
movq   $0x0,-0x8(%rbp)
jmp    189d <string_convert_escaped_chars+0x74d>
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,%edi
add    $0x1,%edi
call   1060 <malloc@plt>
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
jne    11a3 <string_convert_escaped_chars+0x53>
movq   $0x0,-0x8(%rbp)
jmp    189d <string_convert_escaped_chars+0x74d>
movl   $0x0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x18(%rbp)
xor    %eax,%eax
cmpq   $0x0,-0x18(%rbp)
mov    %al,-0x41(%rbp)
je     11d2 <string_convert_escaped_chars+0x82>
mov    -0x18(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x41(%rbp)
mov    -0x41(%rbp),%al
test   $0x1,%al
jne    11e2 <string_convert_escaped_chars+0x92>
jmp    1889 <string_convert_escaped_chars+0x739>
mov    -0x18(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x5c,%eax
jne    185d <string_convert_escaped_chars+0x70d>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
movzbl (%rax),%eax
add    $0xffffffde,%eax
mov    %eax,%ecx
mov    %rcx,-0x50(%rbp)
sub    $0x56,%eax
ja     1809 <string_convert_escaped_chars+0x6b9>
mov    -0x50(%rbp),%rax
lea    0xdde(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x34(%rbp)
movslq %ecx,%rcx
movb   $0x22,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1858 <string_convert_escaped_chars+0x708>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x34(%rbp)
movslq %ecx,%rcx
movb   $0x5c,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1858 <string_convert_escaped_chars+0x708>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x34(%rbp)
movslq %ecx,%rcx
movb   $0x7,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1858 <string_convert_escaped_chars+0x708>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x34(%rbp)
movslq %ecx,%rcx
movb   $0x8,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1858 <string_convert_escaped_chars+0x708>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x34(%rbp)
movslq %ecx,%rcx
movb   $0x1b,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1858 <string_convert_escaped_chars+0x708>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x34(%rbp)
movslq %ecx,%rcx
movb   $0xc,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1858 <string_convert_escaped_chars+0x708>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x34(%rbp)
movslq %ecx,%rcx
movb   $0xa,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1858 <string_convert_escaped_chars+0x708>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x34(%rbp)
movslq %ecx,%rcx
movb   $0xd,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1858 <string_convert_escaped_chars+0x708>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x34(%rbp)
movslq %ecx,%rcx
movb   $0x9,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1858 <string_convert_escaped_chars+0x708>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x34(%rbp)
movslq %ecx,%rcx
movb   $0xb,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1858 <string_convert_escaped_chars+0x708>
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x38(%rbp)
xor    %eax,%eax
cmpl   $0x3,-0x38(%rbp)
mov    %al,-0x51(%rbp)
jge    140d <string_convert_escaped_chars+0x2bd>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x30,%ecx
mov    %al,-0x52(%rbp)
jl     1407 <string_convert_escaped_chars+0x2b7>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x37,%eax
setle  %al
mov    %al,-0x52(%rbp)
mov    -0x52(%rbp),%al
mov    %al,-0x51(%rbp)
mov    -0x51(%rbp),%al
test   $0x1,%al
jne    141d <string_convert_escaped_chars+0x2cd>
jmp    144a <string_convert_escaped_chars+0x2fa>
mov    -0x40(%rbp),%eax
shl    $0x3,%eax
mov    -0x18(%rbp),%rcx
mov    -0x38(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
sub    $0x30,%ecx
add    %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13bf <string_convert_escaped_chars+0x26f>
mov    -0x40(%rbp),%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x34(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
jmp    1858 <string_convert_escaped_chars+0x708>
mov    -0x18(%rbp),%rax
movzbl 0x1(%rax),%edi
call   1070 <isxdigit@plt>
cmp    $0x0,%eax
je     15f7 <string_convert_escaped_chars+0x4a7>
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x38(%rbp)
xor    %eax,%eax
cmpl   $0x2,-0x38(%rbp)
mov    %al,-0x53(%rbp)
jge    14cf <string_convert_escaped_chars+0x37f>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
call   1070 <isxdigit@plt>
cmp    $0x0,%eax
setne  %al
mov    %al,-0x53(%rbp)
mov    -0x53(%rbp),%al
test   $0x1,%al
jne    14df <string_convert_escaped_chars+0x38f>
jmp    15c4 <string_convert_escaped_chars+0x474>
mov    -0x40(%rbp),%eax
shl    $0x4,%eax
mov    %eax,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x61,%eax
jl     153b <string_convert_escaped_chars+0x3eb>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x66,%eax
jg     153b <string_convert_escaped_chars+0x3eb>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
sub    $0x61,%eax
add    $0xa,%eax
mov    %eax,-0x5c(%rbp)
jmp    15ab <string_convert_escaped_chars+0x45b>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x41,%eax
jl     158e <string_convert_escaped_chars+0x43e>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x46,%eax
jg     158e <string_convert_escaped_chars+0x43e>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
sub    $0x41,%eax
add    $0xa,%eax
mov    %eax,-0x60(%rbp)
jmp    15a5 <string_convert_escaped_chars+0x455>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
sub    $0x30,%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x5c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    14a1 <string_convert_escaped_chars+0x351>
mov    -0x40(%rbp),%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x34(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
jmp    161e <string_convert_escaped_chars+0x4ce>
mov    -0x18(%rbp),%rax
mov    (%rax),%dl
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x34(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1858 <string_convert_escaped_chars+0x708>
mov    -0x18(%rbp),%rax
movzbl 0x1(%rax),%edi
call   1070 <isxdigit@plt>
cmp    $0x0,%eax
je     17dd <string_convert_escaped_chars+0x68d>
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%ecx
mov    -0x18(%rbp),%rax
movzbl (%rax),%esi
mov    $0x8,%edx
mov    $0x4,%eax
cmp    $0x75,%esi
cmove  %eax,%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x61(%rbp)
jge    168d <string_convert_escaped_chars+0x53d>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edi
call   1070 <isxdigit@plt>
cmp    $0x0,%eax
setne  %al
mov    %al,-0x61(%rbp)
mov    -0x61(%rbp),%al
test   $0x1,%al
jne    169d <string_convert_escaped_chars+0x54d>
jmp    1782 <string_convert_escaped_chars+0x632>
mov    -0x40(%rbp),%eax
shl    $0x4,%eax
mov    %eax,-0x68(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x61,%eax
jl     16f9 <string_convert_escaped_chars+0x5a9>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x66,%eax
jg     16f9 <string_convert_escaped_chars+0x5a9>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
sub    $0x61,%eax
add    $0xa,%eax
mov    %eax,-0x6c(%rbp)
jmp    1769 <string_convert_escaped_chars+0x619>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x41,%eax
jl     174c <string_convert_escaped_chars+0x5fc>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x46,%eax
jg     174c <string_convert_escaped_chars+0x5fc>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
sub    $0x41,%eax
add    $0xa,%eax
mov    %eax,-0x70(%rbp)
jmp    1763 <string_convert_escaped_chars+0x613>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
sub    $0x30,%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x68(%rbp),%eax
mov    -0x6c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1647 <string_convert_escaped_chars+0x4f7>
mov    -0x40(%rbp),%edi
lea    -0x30(%rbp),%rsi
call   1040 <utf8_int_string@plt>
cmpb   $0x0,-0x30(%rbp)
je     17c4 <string_convert_escaped_chars+0x674>
lea    -0x30(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x3c(%rbp)
mov    -0x20(%rbp),%rdi
movslq -0x34(%rbp),%rax
add    %rax,%rdi
lea    -0x30(%rbp),%rsi
mov    -0x3c(%rbp),%edx
call   1050 <memcpy@plt>
mov    -0x3c(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
jmp    1804 <string_convert_escaped_chars+0x6b4>
mov    -0x18(%rbp),%rax
mov    (%rax),%dl
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x34(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1858 <string_convert_escaped_chars+0x708>
mov    -0x18(%rbp),%rax
cmpb   $0x0,(%rax)
je     1853 <string_convert_escaped_chars+0x703>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x34(%rbp)
movslq %ecx,%rcx
movb   $0x5c,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    (%rax),%dl
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x34(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1858 <string_convert_escaped_chars+0x708>
jmp    1884 <string_convert_escaped_chars+0x734>
mov    -0x18(%rbp),%rax
mov    (%rax),%dl
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x34(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    11b2 <string_convert_escaped_chars+0x62>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<string_convert_escaped_chars>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
test   %rdi,%rdi
je     14a4 <string_convert_escaped_chars+0x354>
mov    %rdi,%r14
call   1030 <strlen@plt>
lea    0x1(%rax),%edi
call   1060 <malloc@plt>
xor    %r12d,%r12d
test   %rax,%rax
je     14a4 <string_convert_escaped_chars+0x354>
mov    %rax,%rbp
lea    0xe73(%rip),%r13
mov    %rax,0x8(%rsp)
jmp    11a7 <string_convert_escaped_chars+0x57>
movslq %r12d,%rax
add    $0x1,%r12d
movb   $0x22,0x0(%rbp,%rax,1)
add    $0x2,%rbx
mov    %rbx,%r14
mov    %r14,%rbx
mov    (%r14),%al
cmp    $0x5c,%al
je     11d0 <string_convert_escaped_chars+0x80>
test   %al,%al
je     14a8 <string_convert_escaped_chars+0x358>
movslq %r12d,%rcx
add    $0x1,%r12d
mov    %al,0x0(%rbp,%rcx,1)
add    $0x1,%rbx
mov    %rbx,%r14
jmp    11a7 <string_convert_escaped_chars+0x57>
nopl   (%rax)
movzbl 0x1(%rbx),%eax
cmp    $0x78,%rax
ja     13c6 <string_convert_escaped_chars+0x276>
lea    0x1(%rbx),%r14
movslq 0x0(%r13,%rax,4),%rax
add    %r13,%rax
jmp    *%rax
movzbl 0x2(%rbx),%edi
call   1070 <isxdigit@plt>
test   %eax,%eax
je     1335 <string_convert_escaped_chars+0x1e5>
mov    $0xffffffc9,%r15d
xor    %r13d,%r13d
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movzbl 0x2(%rbx,%r13,1),%edi
call   1070 <isxdigit@plt>
test   %eax,%eax
je     1263 <string_convert_escaped_chars+0x113>
shl    $0x4,%ebp
movzbl 0x2(%rbx,%r13,1),%eax
add    $0x1,%r13
lea    -0x61(%rax),%ecx
lea    -0x41(%rax),%edx
cmp    $0x6,%dl
mov    $0xffffffd0,%edx
cmovb  %r15d,%edx
cmp    $0x6,%cl
mov    $0xffffffa9,%ecx
cmovb  %ecx,%edx
add    %eax,%edx
add    %edx,%ebp
xor    %eax,%eax
cmpb   $0x75,0x1(%rbx)
setne  %al
lea    0x4(,%rax,4),%rax
cmp    %rax,%r13
jb     1210 <string_convert_escaped_chars+0xc0>
mov    %ebp,%edi
lea    0x10(%rsp),%r15
mov    %r15,%rsi
call   1040 <utf8_int_string@plt>
cmpb   $0x0,0x10(%rsp)
je     1464 <string_convert_escaped_chars+0x314>
mov    %r15,%rdi
call   1030 <strlen@plt>
mov    %eax,%ebx
movslq %r12d,%rdi
mov    0x8(%rsp),%rbp
add    %rbp,%rdi
mov    %r15,%rsi
mov    %eax,%edx
call   1050 <memcpy@plt>
add    %ebx,%r12d
jmp    1469 <string_convert_escaped_chars+0x319>
movzbl 0x2(%rbx),%edi
call   1070 <isxdigit@plt>
test   %eax,%eax
je     1335 <string_convert_escaped_chars+0x1e5>
movzbl 0x2(%rbx),%edi
call   1070 <isxdigit@plt>
test   %eax,%eax
je     147c <string_convert_escaped_chars+0x32c>
movzbl 0x2(%rbx),%eax
lea    -0x61(%rax),%ecx
lea    -0x41(%rax),%edx
cmp    $0x6,%dl
mov    $0xffffffc9,%ebp
mov    $0xffffffa9,%edx
mov    $0xffffffd0,%r15d
cmovb  %ebp,%r15d
cmp    $0x6,%cl
cmovb  %edx,%r15d
add    %eax,%r15d
movzbl 0x3(%rbx),%edi
call   1070 <isxdigit@plt>
test   %eax,%eax
je     1486 <string_convert_escaped_chars+0x336>
shl    $0x4,%r15d
movzbl 0x3(%rbx),%eax
lea    -0x41(%rax),%ecx
cmp    $0x6,%cl
mov    $0xffffffd0,%ecx
cmovb  %ebp,%ecx
lea    -0x61(%rax),%edx
cmp    $0x6,%dl
mov    $0xffffffa9,%edx
cmovb  %edx,%ecx
add    %eax,%ecx
add    %ecx,%r15d
mov    $0x3,%eax
jmp    148b <string_convert_escaped_chars+0x33b>
add    $0x2,%rbx
mov    (%r14),%al
movslq %r12d,%rcx
add    $0x1,%r12d
mov    %al,0x0(%rbp,%rcx,1)
mov    %rbx,%r14
jmp    11a7 <string_convert_escaped_chars+0x57>
movslq %r12d,%rax
add    $0x1,%r12d
movb   $0x5c,0x0(%rbp,%rax,1)
jmp    11a0 <string_convert_escaped_chars+0x50>
movslq %r12d,%rax
add    $0x1,%r12d
movb   $0x7,0x0(%rbp,%rax,1)
jmp    11a0 <string_convert_escaped_chars+0x50>
movslq %r12d,%rax
add    $0x1,%r12d
movb   $0x8,0x0(%rbp,%rax,1)
jmp    11a0 <string_convert_escaped_chars+0x50>
movslq %r12d,%rax
add    $0x1,%r12d
movb   $0xc,0x0(%rbp,%rax,1)
jmp    11a0 <string_convert_escaped_chars+0x50>
movslq %r12d,%rax
add    $0x1,%r12d
movb   $0xa,0x0(%rbp,%rax,1)
jmp    11a0 <string_convert_escaped_chars+0x50>
movslq %r12d,%rax
add    $0x1,%r12d
movb   $0xd,0x0(%rbp,%rax,1)
jmp    11a0 <string_convert_escaped_chars+0x50>
movslq %r12d,%rax
add    $0x1,%r12d
movb   $0x9,0x0(%rbp,%rax,1)
jmp    11a0 <string_convert_escaped_chars+0x50>
movslq %r12d,%rax
movb   $0x5c,0x0(%rbp,%rax,1)
mov    0x1(%rbx),%cl
add    $0x2,%r12d
mov    %cl,0x1(%rbp,%rax,1)
jmp    11a0 <string_convert_escaped_chars+0x50>
movzbl 0x2(%rbx),%eax
mov    %eax,%ecx
and    $0xf8,%cl
cmp    $0x30,%cl
jne    144a <string_convert_escaped_chars+0x2fa>
add    $0xffffffd0,%eax
movzbl 0x3(%rbx),%esi
mov    %esi,%edx
and    $0xf8,%dl
mov    $0x2,%ecx
cmp    $0x30,%dl
jne    1451 <string_convert_escaped_chars+0x301>
lea    (%rsi,%rax,8),%eax
add    $0xffffffd0,%eax
movzbl 0x4(%rbx),%edx
mov    %edx,%ebx
and    $0xf8,%bl
mov    $0x3,%ecx
cmp    $0x30,%bl
jne    1451 <string_convert_escaped_chars+0x301>
lea    (%rdx,%rax,8),%eax
add    $0xffffffd0,%eax
mov    $0x4,%ecx
jmp    1451 <string_convert_escaped_chars+0x301>
movslq %r12d,%rax
add    $0x1,%r12d
movb   $0x1b,0x0(%rbp,%rax,1)
jmp    11a0 <string_convert_escaped_chars+0x50>
movslq %r12d,%rax
add    $0x1,%r12d
movb   $0xb,0x0(%rbp,%rax,1)
jmp    11a0 <string_convert_escaped_chars+0x50>
xor    %eax,%eax
mov    $0x1,%ecx
movslq %r12d,%rdx
add    $0x1,%r12d
mov    %al,0x0(%rbp,%rdx,1)
add    %rcx,%r14
jmp    11a7 <string_convert_escaped_chars+0x57>
mov    0x8(%rsp),%rbp
add    $0x1,%r13d
add    %r13,%r14
lea    0xb89(%rip),%r13
jmp    11a7 <string_convert_escaped_chars+0x57>
xor    %r15d,%r15d
mov    $0x1,%eax
jmp    1490 <string_convert_escaped_chars+0x340>
mov    $0x2,%eax
mov    0x8(%rsp),%rbp
movslq %r12d,%rcx
add    $0x1,%r12d
mov    %r15b,0x0(%rbp,%rcx,1)
add    %rax,%r14
jmp    11a7 <string_convert_escaped_chars+0x57>
xor    %ebp,%ebp
jmp    14b0 <string_convert_escaped_chars+0x360>
movslq %r12d,%rax
movb   $0x0,0x0(%rbp,%rax,1)
mov    %rbp,%rax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i8* @string_convert_escaped_chars(i8* %0) {
%2 = alloca i8*
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca [16 x i8]
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
store i8* %0, i8** %3
%11 = load i8*, i8** %3
%12 = icmp ne i8* %11, null
br i1 %12, label %14, label %13
13: ; preds = %1
store i8* null, i8** %2
br label %485
14: ; preds = %1
%15 = load i8*, i8** %3
%16 = call i32 @strlen(i8* %15)
%17 = add nsw i32 %16, 1
%18 = call i8* @malloc(i32 %17)
store i8* %18, i8** %5
%19 = load i8*, i8** %5
%20 = icmp ne i8* %19, null
br i1 %20, label %22, label %21
21: ; preds = %14
store i8* null, i8** %2
br label %485
22: ; preds = %14
store i32 0, i32* %7
%23 = load i8*, i8** %3
store i8* %23, i8** %4
br label %24
24: ; preds = %478, %22
%25 = load i8*, i8** %4
%26 = icmp ne i8* %25, null
br i1 %26, label %27, label %33
27: ; preds = %24
%28 = load i8*, i8** %4
%29 = getelementptr inbounds i8, i8* %28, i64 0
%30 = load i8, i8* %29
%31 = zext i8 %30 to i32
%32 = icmp ne i32 %31, 0
br label %33
33: ; preds = %27, %24
%34 = phi i1 [ false, %24 ], [ %32, %27 ]
br i1 %34, label %35, label %479
35: ; preds = %33
%36 = load i8*, i8** %4
%37 = getelementptr inbounds i8, i8* %36, i64 0
%38 = load i8, i8* %37
%39 = zext i8 %38 to i32
%40 = icmp eq i32 %39, 92
br i1 %40, label %41, label %467
41: ; preds = %35
%42 = load i8*, i8** %4
%43 = getelementptr inbounds i8, i8* %42, i32 1
store i8* %43, i8** %4
%44 = load i8*, i8** %4
%45 = getelementptr inbounds i8, i8* %44, i64 0
%46 = load i8, i8* %45
%47 = zext i8 %46 to i32
switch i32 %47, label %444 [
i32 34, label %48
i32 92, label %56
i32 97, label %64
i32 98, label %72
i32 101, label %80
i32 102, label %88
i32 110, label %96
i32 114, label %104
i32 116, label %112
i32 118, label %120
i32 48, label %128
i32 120, label %182
i32 88, label %182
i32 117, label %303
i32 85, label %303
]
48: ; preds = %41
%49 = load i8*, i8** %5
%50 = load i32, i32* %7
%51 = add nsw i32 %50, 1
store i32 %51, i32* %7
%52 = sext i32 %50 to i64
%53 = getelementptr inbounds i8, i8* %49, i64 %52
store i8 34, i8* %53
%54 = load i8*, i8** %4
%55 = getelementptr inbounds i8, i8* %54, i32 1
store i8* %55, i8** %4
br label %466
56: ; preds = %41
%57 = load i8*, i8** %5
%58 = load i32, i32* %7
%59 = add nsw i32 %58, 1
store i32 %59, i32* %7
%60 = sext i32 %58 to i64
%61 = getelementptr inbounds i8, i8* %57, i64 %60
store i8 92, i8* %61
%62 = load i8*, i8** %4
%63 = getelementptr inbounds i8, i8* %62, i32 1
store i8* %63, i8** %4
br label %466
64: ; preds = %41
%65 = load i8*, i8** %5
%66 = load i32, i32* %7
%67 = add nsw i32 %66, 1
store i32 %67, i32* %7
%68 = sext i32 %66 to i64
%69 = getelementptr inbounds i8, i8* %65, i64 %68
store i8 7, i8* %69
%70 = load i8*, i8** %4
%71 = getelementptr inbounds i8, i8* %70, i32 1
store i8* %71, i8** %4
br label %466
72: ; preds = %41
%73 = load i8*, i8** %5
%74 = load i32, i32* %7
%75 = add nsw i32 %74, 1
store i32 %75, i32* %7
%76 = sext i32 %74 to i64
%77 = getelementptr inbounds i8, i8* %73, i64 %76
store i8 8, i8* %77
%78 = load i8*, i8** %4
%79 = getelementptr inbounds i8, i8* %78, i32 1
store i8* %79, i8** %4
br label %466
80: ; preds = %41
%81 = load i8*, i8** %5
%82 = load i32, i32* %7
%83 = add nsw i32 %82, 1
store i32 %83, i32* %7
%84 = sext i32 %82 to i64
%85 = getelementptr inbounds i8, i8* %81, i64 %84
store i8 27, i8* %85
%86 = load i8*, i8** %4
%87 = getelementptr inbounds i8, i8* %86, i32 1
store i8* %87, i8** %4
br label %466
88: ; preds = %41
%89 = load i8*, i8** %5
%90 = load i32, i32* %7
%91 = add nsw i32 %90, 1
store i32 %91, i32* %7
%92 = sext i32 %90 to i64
%93 = getelementptr inbounds i8, i8* %89, i64 %92
store i8 12, i8* %93
%94 = load i8*, i8** %4
%95 = getelementptr inbounds i8, i8* %94, i32 1
store i8* %95, i8** %4
br label %466
96: ; preds = %41
%97 = load i8*, i8** %5
%98 = load i32, i32* %7
%99 = add nsw i32 %98, 1
store i32 %99, i32* %7
%100 = sext i32 %98 to i64
%101 = getelementptr inbounds i8, i8* %97, i64 %100
store i8 10, i8* %101
%102 = load i8*, i8** %4
%103 = getelementptr inbounds i8, i8* %102, i32 1
store i8* %103, i8** %4
br label %466
104: ; preds = %41
%105 = load i8*, i8** %5
%106 = load i32, i32* %7
%107 = add nsw i32 %106, 1
store i32 %107, i32* %7
%108 = sext i32 %106 to i64
%109 = getelementptr inbounds i8, i8* %105, i64 %108
store i8 13, i8* %109
%110 = load i8*, i8** %4
%111 = getelementptr inbounds i8, i8* %110, i32 1
store i8* %111, i8** %4
br label %466
112: ; preds = %41
%113 = load i8*, i8** %5
%114 = load i32, i32* %7
%115 = add nsw i32 %114, 1
store i32 %115, i32* %7
%116 = sext i32 %114 to i64
%117 = getelementptr inbounds i8, i8* %113, i64 %116
store i8 9, i8* %117
%118 = load i8*, i8** %4
%119 = getelementptr inbounds i8, i8* %118, i32 1
store i8* %119, i8** %4
br label %466
120: ; preds = %41
%121 = load i8*, i8** %5
%122 = load i32, i32* %7
%123 = add nsw i32 %122, 1
store i32 %123, i32* %7
%124 = sext i32 %122 to i64
%125 = getelementptr inbounds i8, i8* %121, i64 %124
store i8 11, i8* %125
%126 = load i8*, i8** %4
%127 = getelementptr inbounds i8, i8* %126, i32 1
store i8* %127, i8** %4
br label %466
128: ; preds = %41
store i32 0, i32* %10
store i32 0, i32* %8
br label %129
129: ; preds = %166, %128
%130 = load i32, i32* %8
%131 = icmp slt i32 %130, 3
br i1 %131, label %132, label %152
132: ; preds = %129
%133 = load i8*, i8** %4
%134 = load i32, i32* %8
%135 = add nsw i32 %134, 1
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds i8, i8* %133, i64 %136
%138 = load i8, i8* %137
%139 = zext i8 %138 to i32
%140 = icmp sge i32 %139, 48
br i1 %140, label %141, label %150
141: ; preds = %132
%142 = load i8*, i8** %4
%143 = load i32, i32* %8
%144 = add nsw i32 %143, 1
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds i8, i8* %142, i64 %145
%147 = load i8, i8* %146
%148 = zext i8 %147 to i32
%149 = icmp sle i32 %148, 55
br label %150
150: ; preds = %141, %132
%151 = phi i1 [ false, %132 ], [ %149, %141 ]
br label %152
152: ; preds = %150, %129
%153 = phi i1 [ false, %129 ], [ %151, %150 ]
br i1 %153, label %154, label %169
154: ; preds = %152
%155 = load i32, i32* %10
%156 = mul i32 %155, 8
%157 = load i8*, i8** %4
%158 = load i32, i32* %8
%159 = add nsw i32 %158, 1
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds i8, i8* %157, i64 %160
%162 = load i8, i8* %161
%163 = zext i8 %162 to i32
%164 = sub nsw i32 %163, 48
%165 = add i32 %156, %164
store i32 %165, i32* %10
br label %166
166: ; preds = %154
%167 = load i32, i32* %8
%168 = add nsw i32 %167, 1
store i32 %168, i32* %8
br label %129
169: ; preds = %152
%170 = load i32, i32* %10
%171 = trunc i32 %170 to i8
%172 = load i8*, i8** %5
%173 = load i32, i32* %7
%174 = add nsw i32 %173, 1
store i32 %174, i32* %7
%175 = sext i32 %173 to i64
%176 = getelementptr inbounds i8, i8* %172, i64 %175
store i8 %171, i8* %176
%177 = load i32, i32* %8
%178 = add nsw i32 1, %177
%179 = load i8*, i8** %4
%180 = sext i32 %178 to i64
%181 = getelementptr inbounds i8, i8* %179, i64 %180
store i8* %181, i8** %4
br label %466
182: ; preds = %41, %41
%183 = load i8*, i8** %4
%184 = getelementptr inbounds i8, i8* %183, i64 1
%185 = load i8, i8* %184
%186 = call i32 @isxdigit(i8 zeroext %185)
%187 = icmp ne i32 %186, 0
br i1 %187, label %188, label %291
188: ; preds = %182
store i32 0, i32* %10
store i32 0, i32* %8
br label %189
189: ; preds = %275, %188
%190 = load i32, i32* %8
%191 = icmp slt i32 %190, 2
br i1 %191, label %192, label %201
192: ; preds = %189
%193 = load i8*, i8** %4
%194 = load i32, i32* %8
%195 = add nsw i32 %194, 1
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds i8, i8* %193, i64 %196
%198 = load i8, i8* %197
%199 = call i32 @isxdigit(i8 zeroext %198)
%200 = icmp ne i32 %199, 0
br label %201
201: ; preds = %192, %189
%202 = phi i1 [ false, %189 ], [ %200, %192 ]
br i1 %202, label %203, label %278
203: ; preds = %201
%204 = load i32, i32* %10
%205 = mul i32 %204, 16
%206 = load i8*, i8** %4
%207 = load i32, i32* %8
%208 = add nsw i32 %207, 1
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds i8, i8* %206, i64 %209
%211 = load i8, i8* %210
%212 = zext i8 %211 to i32
%213 = icmp sge i32 %212, 97
br i1 %213, label %214, label %233
214: ; preds = %203
%215 = load i8*, i8** %4
%216 = load i32, i32* %8
%217 = add nsw i32 %216, 1
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds i8, i8* %215, i64 %218
%220 = load i8, i8* %219
%221 = zext i8 %220 to i32
%222 = icmp sle i32 %221, 102
br i1 %222, label %223, label %233
223: ; preds = %214
%224 = load i8*, i8** %4
%225 = load i32, i32* %8
%226 = add nsw i32 %225, 1
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds i8, i8* %224, i64 %227
%229 = load i8, i8* %228
%230 = zext i8 %229 to i32
%231 = sub nsw i32 %230, 97
%232 = add nsw i32 %231, 10
br label %272
233: ; preds = %214, %203
%234 = load i8*, i8** %4
%235 = load i32, i32* %8
%236 = add nsw i32 %235, 1
%237 = sext i32 %236 to i64
%238 = getelementptr inbounds i8, i8* %234, i64 %237
%239 = load i8, i8* %238
%240 = zext i8 %239 to i32
%241 = icmp sge i32 %240, 65
br i1 %241, label %242, label %261
242: ; preds = %233
%243 = load i8*, i8** %4
%244 = load i32, i32* %8
%245 = add nsw i32 %244, 1
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds i8, i8* %243, i64 %246
%248 = load i8, i8* %247
%249 = zext i8 %248 to i32
%250 = icmp sle i32 %249, 70
br i1 %250, label %251, label %261
251: ; preds = %242
%252 = load i8*, i8** %4
%253 = load i32, i32* %8
%254 = add nsw i32 %253, 1
%255 = sext i32 %254 to i64
%256 = getelementptr inbounds i8, i8* %252, i64 %255
%257 = load i8, i8* %256
%258 = zext i8 %257 to i32
%259 = sub nsw i32 %258, 65
%260 = add nsw i32 %259, 10
br label %270
261: ; preds = %242, %233
%262 = load i8*, i8** %4
%263 = load i32, i32* %8
%264 = add nsw i32 %263, 1
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds i8, i8* %262, i64 %265
%267 = load i8, i8* %266
%268 = zext i8 %267 to i32
%269 = sub nsw i32 %268, 48
br label %270
270: ; preds = %261, %251
%271 = phi i32 [ %260, %251 ], [ %269, %261 ]
br label %272
272: ; preds = %270, %223
%273 = phi i32 [ %232, %223 ], [ %271, %270 ]
%274 = add i32 %205, %273
store i32 %274, i32* %10
br label %275
275: ; preds = %272
%276 = load i32, i32* %8
%277 = add nsw i32 %276, 1
store i32 %277, i32* %8
br label %189
278: ; preds = %201
%279 = load i32, i32* %10
%280 = trunc i32 %279 to i8
%281 = load i8*, i8** %5
%282 = load i32, i32* %7
%283 = add nsw i32 %282, 1
store i32 %283, i32* %7
%284 = sext i32 %282 to i64
%285 = getelementptr inbounds i8, i8* %281, i64 %284
store i8 %280, i8* %285
%286 = load i32, i32* %8
%287 = add nsw i32 1, %286
%288 = load i8*, i8** %4
%289 = sext i32 %287 to i64
%290 = getelementptr inbounds i8, i8* %288, i64 %289
store i8* %290, i8** %4
br label %302
291: ; preds = %182
%292 = load i8*, i8** %4
%293 = getelementptr inbounds i8, i8* %292, i64 0
%294 = load i8, i8* %293
%295 = load i8*, i8** %5
%296 = load i32, i32* %7
%297 = add nsw i32 %296, 1
store i32 %297, i32* %7
%298 = sext i32 %296 to i64
%299 = getelementptr inbounds i8, i8* %295, i64 %298
store i8 %294, i8* %299
%300 = load i8*, i8** %4
%301 = getelementptr inbounds i8, i8* %300, i32 1
store i8* %301, i8** %4
br label %302
302: ; preds = %291, %278
br label %466
303: ; preds = %41, %41
%304 = load i8*, i8** %4
%305 = getelementptr inbounds i8, i8* %304, i64 1
%306 = load i8, i8* %305
%307 = call i32 @isxdigit(i8 zeroext %306)
%308 = icmp ne i32 %307, 0
br i1 %308, label %309, label %432
309: ; preds = %303
store i32 0, i32* %10
store i32 0, i32* %8
br label %310
310: ; preds = %403, %309
%311 = load i32, i32* %8
%312 = load i8*, i8** %4
%313 = getelementptr inbounds i8, i8* %312, i64 0
%314 = load i8, i8* %313
%315 = zext i8 %314 to i32
%316 = icmp eq i32 %315, 117
%317 = zext i1 %316 to i64
%318 = select i1 %316, i32 4, i32 8
%319 = icmp slt i32 %311, %318
br i1 %319, label %320, label %329
320: ; preds = %310
%321 = load i8*, i8** %4
%322 = load i32, i32* %8
%323 = add nsw i32 %322, 1
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds i8, i8* %321, i64 %324
%326 = load i8, i8* %325
%327 = call i32 @isxdigit(i8 zeroext %326)
%328 = icmp ne i32 %327, 0
br label %329
329: ; preds = %320, %310
%330 = phi i1 [ false, %310 ], [ %328, %320 ]
br i1 %330, label %331, label %406
331: ; preds = %329
%332 = load i32, i32* %10
%333 = mul i32 %332, 16
%334 = load i8*, i8** %4
%335 = load i32, i32* %8
%336 = add nsw i32 %335, 1
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds i8, i8* %334, i64 %337
%339 = load i8, i8* %338
%340 = zext i8 %339 to i32
%341 = icmp sge i32 %340, 97
br i1 %341, label %342, label %361
342: ; preds = %331
%343 = load i8*, i8** %4
%344 = load i32, i32* %8
%345 = add nsw i32 %344, 1
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds i8, i8* %343, i64 %346
%348 = load i8, i8* %347
%349 = zext i8 %348 to i32
%350 = icmp sle i32 %349, 102
br i1 %350, label %351, label %361
351: ; preds = %342
%352 = load i8*, i8** %4
%353 = load i32, i32* %8
%354 = add nsw i32 %353, 1
%355 = sext i32 %354 to i64
%356 = getelementptr inbounds i8, i8* %352, i64 %355
%357 = load i8, i8* %356
%358 = zext i8 %357 to i32
%359 = sub nsw i32 %358, 97
%360 = add nsw i32 %359, 10
br label %400
361: ; preds = %342, %331
%362 = load i8*, i8** %4
%363 = load i32, i32* %8
%364 = add nsw i32 %363, 1
%365 = sext i32 %364 to i64
%366 = getelementptr inbounds i8, i8* %362, i64 %365
%367 = load i8, i8* %366
%368 = zext i8 %367 to i32
%369 = icmp sge i32 %368, 65
br i1 %369, label %370, label %389
370: ; preds = %361
%371 = load i8*, i8** %4
%372 = load i32, i32* %8
%373 = add nsw i32 %372, 1
%374 = sext i32 %373 to i64
%375 = getelementptr inbounds i8, i8* %371, i64 %374
%376 = load i8, i8* %375
%377 = zext i8 %376 to i32
%378 = icmp sle i32 %377, 70
br i1 %378, label %379, label %389
379: ; preds = %370
%380 = load i8*, i8** %4
%381 = load i32, i32* %8
%382 = add nsw i32 %381, 1
%383 = sext i32 %382 to i64
%384 = getelementptr inbounds i8, i8* %380, i64 %383
%385 = load i8, i8* %384
%386 = zext i8 %385 to i32
%387 = sub nsw i32 %386, 65
%388 = add nsw i32 %387, 10
br label %398
389: ; preds = %370, %361
%390 = load i8*, i8** %4
%391 = load i32, i32* %8
%392 = add nsw i32 %391, 1
%393 = sext i32 %392 to i64
%394 = getelementptr inbounds i8, i8* %390, i64 %393
%395 = load i8, i8* %394
%396 = zext i8 %395 to i32
%397 = sub nsw i32 %396, 48
br label %398
398: ; preds = %389, %379
%399 = phi i32 [ %388, %379 ], [ %397, %389 ]
br label %400
400: ; preds = %398, %351
%401 = phi i32 [ %360, %351 ], [ %399, %398 ]
%402 = add i32 %333, %401
store i32 %402, i32* %10
br label %403
403: ; preds = %400
%404 = load i32, i32* %8
%405 = add nsw i32 %404, 1
store i32 %405, i32* %8
br label %310
406: ; preds = %329
%407 = load i32, i32* %10
%408 = getelementptr inbounds [16 x i8], [16 x i8]* %6, i64 0, i64 0
%409 = call i32 @utf8_int_string(i32 %407, i8* %408)
%410 = getelementptr inbounds [16 x i8], [16 x i8]* %6, i64 0, i64 0
%411 = load i8, i8* %410
%412 = icmp ne i8 %411, 0
br i1 %412, label %413, label %426
413: ; preds = %406
%414 = getelementptr inbounds [16 x i8], [16 x i8]* %6, i64 0, i64 0
%415 = call i32 @strlen(i8* %414)
store i32 %415, i32* %9
%416 = load i8*, i8** %5
%417 = load i32, i32* %7
%418 = sext i32 %417 to i64
%419 = getelementptr inbounds i8, i8* %416, i64 %418
%420 = getelementptr inbounds [16 x i8], [16 x i8]* %6, i64 0, i64 0
%421 = load i32, i32* %9
%422 = call i32 @memcpy(i8* %419, i8* %420, i32 %421)
%423 = load i32, i32* %9
%424 = load i32, i32* %7
%425 = add nsw i32 %424, %423
store i32 %425, i32* %7
br label %426
426: ; preds = %413, %406
%427 = load i32, i32* %8
%428 = add nsw i32 1, %427
%429 = load i8*, i8** %4
%430 = sext i32 %428 to i64
%431 = getelementptr inbounds i8, i8* %429, i64 %430
store i8* %431, i8** %4
br label %443
432: ; preds = %303
%433 = load i8*, i8** %4
%434 = getelementptr inbounds i8, i8* %433, i64 0
%435 = load i8, i8* %434
%436 = load i8*, i8** %5
%437 = load i32, i32* %7
%438 = add nsw i32 %437, 1
store i32 %438, i32* %7
%439 = sext i32 %437 to i64
%440 = getelementptr inbounds i8, i8* %436, i64 %439
store i8 %435, i8* %440
%441 = load i8*, i8** %4
%442 = getelementptr inbounds i8, i8* %441, i32 1
store i8* %442, i8** %4
br label %443
443: ; preds = %432, %426
br label %466
444: ; preds = %41
%445 = load i8*, i8** %4
%446 = getelementptr inbounds i8, i8* %445, i64 0
%447 = load i8, i8* %446
%448 = icmp ne i8 %447, 0
br i1 %448, label %449, label %465
449: ; preds = %444
%450 = load i8*, i8** %5
%451 = load i32, i32* %7
%452 = add nsw i32 %451, 1
store i32 %452, i32* %7
%453 = sext i32 %451 to i64
%454 = getelementptr inbounds i8, i8* %450, i64 %453
store i8 92, i8* %454
%455 = load i8*, i8** %4
%456 = getelementptr inbounds i8, i8* %455, i64 0
%457 = load i8, i8* %456
%458 = load i8*, i8** %5
%459 = load i32, i32* %7
%460 = add nsw i32 %459, 1
store i32 %460, i32* %7
%461 = sext i32 %459 to i64
%462 = getelementptr inbounds i8, i8* %458, i64 %461
store i8 %457, i8* %462
%463 = load i8*, i8** %4
%464 = getelementptr inbounds i8, i8* %463, i32 1
store i8* %464, i8** %4
br label %465
465: ; preds = %449, %444
br label %466
466: ; preds = %465, %443, %302, %169, %120, %112, %104, %96, %88, %80, %72, %64, %56, %48
br label %478
467: ; preds = %35
%468 = load i8*, i8** %4
%469 = getelementptr inbounds i8, i8* %468, i64 0
%470 = load i8, i8* %469
%471 = load i8*, i8** %5
%472 = load i32, i32* %7
%473 = add nsw i32 %472, 1
store i32 %473, i32* %7
%474 = sext i32 %472 to i64
%475 = getelementptr inbounds i8, i8* %471, i64 %474
store i8 %470, i8* %475
%476 = load i8*, i8** %4
%477 = getelementptr inbounds i8, i8* %476, i32 1
store i8* %477, i8** %4
br label %478
478: ; preds = %467, %466
br label %24
479: ; preds = %33
%480 = load i8*, i8** %5
%481 = load i32, i32* %7
%482 = sext i32 %481 to i64
%483 = getelementptr inbounds i8, i8* %480, i64 %482
store i8 0, i8* %483
%484 = load i8*, i8** %5
store i8* %484, i8** %2
br label %485
485: ; preds = %479, %21, %13
%486 = load i8*, i8** %2
ret i8* %486
}

LLVM IR (-O2):
define i8* @string_convert_escaped_chars(i8* %0) {
%2 = alloca [16 x i8]
%3 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 0
%4 = icmp eq i8* %0, null
br i1 %4, label %221, label %5
5: ; preds = %1
%6 = tail call i32 @strlen(i8* %0)
%7 = add nsw i32 %6, 1
%8 = tail call i8* @malloc(i32 %7)
%9 = icmp eq i8* %8, null
br i1 %9, label %221, label %10
10: ; preds = %5, %17
%11 = phi i8* [ %18, %17 ], [ %0, %5 ]
%12 = phi i32 [ %19, %17 ], [ 0, %5 ]
%13 = load i8, i8* %11
switch i8 %13, label %213 [
i8 0, label %218
i8 92, label %14
]
14: ; preds = %10
%15 = getelementptr inbounds i8, i8* %11, i64 1
%16 = load i8, i8* %15
switch i8 %16, label %204 [
i8 34, label %25
i8 92, label %30
i8 97, label %35
i8 98, label %40
i8 101, label %45
i8 102, label %50
i8 110, label %55
i8 114, label %60
i8 116, label %65
i8 118, label %70
i8 48, label %20
i8 120, label %104
i8 88, label %104
i8 117, label %153
i8 85, label %153
i8 0, label %17
]
17: ; preds = %14, %25, %30, %35, %40, %45, %50, %55, %60, %65, %70, %96, %148, %140, %199, %194, %204, %213
%18 = phi i8* [ %212, %204 ], [ %198, %194 ], [ %154, %199 ], [ %147, %140 ], [ %105, %148 ], [ %103, %96 ], [ %74, %70 ], [ %69, %65 ], [ %64, %60 ], [ %59, %55 ], [ %54, %50 ], [ %49, %45 ], [ %44, %40 ], [ %39, %35 ], [ %34, %30 ], [ %29, %25 ], [ %217, %213 ], [ %15, %14 ]
%19 = phi i32 [ %209, %204 ], [ %195, %194 ], [ %201, %199 ], [ %144, %140 ], [ %150, %148 ], [ %100, %96 ], [ %71, %70 ], [ %66, %65 ], [ %61, %60 ], [ %56, %55 ], [ %51, %50 ], [ %46, %45 ], [ %41, %40 ], [ %36, %35 ], [ %31, %30 ], [ %26, %25 ], [ %214, %213 ], [ %12, %14 ]
br label %10
20: ; preds = %14
%21 = getelementptr inbounds i8, i8* %11, i64 2
%22 = load i8, i8* %21
%23 = and i8 %22, -8
%24 = icmp eq i8 %23, 48
br i1 %24, label %75, label %96
25: ; preds = %14
%26 = add nsw i32 %12, 1
%27 = sext i32 %12 to i64
%28 = getelementptr inbounds i8, i8* %8, i64 %27
store i8 34, i8* %28
%29 = getelementptr inbounds i8, i8* %11, i64 2
br label %17
30: ; preds = %14
%31 = add nsw i32 %12, 1
%32 = sext i32 %12 to i64
%33 = getelementptr inbounds i8, i8* %8, i64 %32
store i8 92, i8* %33
%34 = getelementptr inbounds i8, i8* %11, i64 2
br label %17
35: ; preds = %14
%36 = add nsw i32 %12, 1
%37 = sext i32 %12 to i64
%38 = getelementptr inbounds i8, i8* %8, i64 %37
store i8 7, i8* %38
%39 = getelementptr inbounds i8, i8* %11, i64 2
br label %17
40: ; preds = %14
%41 = add nsw i32 %12, 1
%42 = sext i32 %12 to i64
%43 = getelementptr inbounds i8, i8* %8, i64 %42
store i8 8, i8* %43
%44 = getelementptr inbounds i8, i8* %11, i64 2
br label %17
45: ; preds = %14
%46 = add nsw i32 %12, 1
%47 = sext i32 %12 to i64
%48 = getelementptr inbounds i8, i8* %8, i64 %47
store i8 27, i8* %48
%49 = getelementptr inbounds i8, i8* %11, i64 2
br label %17
50: ; preds = %14
%51 = add nsw i32 %12, 1
%52 = sext i32 %12 to i64
%53 = getelementptr inbounds i8, i8* %8, i64 %52
store i8 12, i8* %53
%54 = getelementptr inbounds i8, i8* %11, i64 2
br label %17
55: ; preds = %14
%56 = add nsw i32 %12, 1
%57 = sext i32 %12 to i64
%58 = getelementptr inbounds i8, i8* %8, i64 %57
store i8 10, i8* %58
%59 = getelementptr inbounds i8, i8* %11, i64 2
br label %17
60: ; preds = %14
%61 = add nsw i32 %12, 1
%62 = sext i32 %12 to i64
%63 = getelementptr inbounds i8, i8* %8, i64 %62
store i8 13, i8* %63
%64 = getelementptr inbounds i8, i8* %11, i64 2
br label %17
65: ; preds = %14
%66 = add nsw i32 %12, 1
%67 = sext i32 %12 to i64
%68 = getelementptr inbounds i8, i8* %8, i64 %67
store i8 9, i8* %68
%69 = getelementptr inbounds i8, i8* %11, i64 2
br label %17
70: ; preds = %14
%71 = add nsw i32 %12, 1
%72 = sext i32 %12 to i64
%73 = getelementptr inbounds i8, i8* %8, i64 %72
store i8 11, i8* %73
%74 = getelementptr inbounds i8, i8* %11, i64 2
br label %17
75: ; preds = %20
%76 = zext i8 %22 to i32
%77 = add nsw i32 %76, -48
%78 = getelementptr inbounds i8, i8* %11, i64 3
%79 = load i8, i8* %78
%80 = and i8 %79, -8
%81 = icmp eq i8 %80, 48
br i1 %81, label %82, label %96
82: ; preds = %75
%83 = zext i8 %79 to i32
%84 = shl nuw nsw i32 %77, 3
%85 = add nsw i32 %84, -48
%86 = add nsw i32 %85, %83
%87 = getelementptr inbounds i8, i8* %11, i64 4
%88 = load i8, i8* %87
%89 = and i8 %88, -8
%90 = icmp eq i8 %89, 48
br i1 %90, label %91, label %96
91: ; preds = %82
%92 = zext i8 %88 to i32
%93 = shl nuw nsw i32 %86, 3
%94 = add nsw i32 %93, -48
%95 = add nsw i32 %94, %92
br label %96
96: ; preds = %91, %82, %75, %20
%97 = phi i64 [ 1, %20 ], [ 2, %75 ], [ 3, %82 ], [ 4, %91 ]
%98 = phi i32 [ 0, %20 ], [ %77, %75 ], [ %86, %82 ], [ %95, %91 ]
%99 = trunc i32 %98 to i8
%100 = add nsw i32 %12, 1
%101 = sext i32 %12 to i64
%102 = getelementptr inbounds i8, i8* %8, i64 %101
store i8 %99, i8* %102
%103 = getelementptr inbounds i8, i8* %15, i64 %97
br label %17
104: ; preds = %14, %14
%105 = getelementptr inbounds i8, i8* %11, i64 2
%106 = load i8, i8* %105
%107 = call i32 @isxdigit(i8 zeroext %106)
%108 = icmp eq i32 %107, 0
br i1 %108, label %148, label %109
109: ; preds = %104
%110 = getelementptr inbounds i8, i8* %11, i64 2
%111 = load i8, i8* %110
%112 = call i32 @isxdigit(i8 zeroext %111)
%113 = icmp eq i32 %112, 0
br i1 %113, label %140, label %114
114: ; preds = %109
%115 = load i8, i8* %110
%116 = zext i8 %115 to i32
%117 = add i8 %115, -97
%118 = icmp ult i8 %117, 6
%119 = add i8 %115, -65
%120 = icmp ult i8 %119, 6
%121 = select i1 %120, i32 -55, i32 -48
%122 = select i1 %118, i32 -87, i32 %121
%123 = add nsw i32 %122, %116
%124 = getelementptr inbounds i8, i8* %11, i64 3
%125 = load i8, i8* %124
%126 = call i32 @isxdigit(i8 zeroext %125)
%127 = icmp eq i32 %126, 0
br i1 %127, label %140, label %128
128: ; preds = %114
%129 = shl nsw i32 %123, 4
%130 = load i8, i8* %124
%131 = zext i8 %130 to i32
%132 = add i8 %130, -97
%133 = icmp ult i8 %132, 6
%134 = add i8 %130, -65
%135 = icmp ult i8 %134, 6
%136 = select i1 %135, i32 -55, i32 -48
%137 = select i1 %133, i32 -87, i32 %136
%138 = add nsw i32 %137, %131
%139 = add nsw i32 %138, %129
br label %140
140: ; preds = %128, %114, %109
%141 = phi i64 [ 1, %109 ], [ 2, %114 ], [ 3, %128 ]
%142 = phi i32 [ 0, %109 ], [ %123, %114 ], [ %139, %128 ]
%143 = trunc i32 %142 to i8
%144 = add nsw i32 %12, 1
%145 = sext i32 %12 to i64
%146 = getelementptr inbounds i8, i8* %8, i64 %145
store i8 %143, i8* %146
%147 = getelementptr inbounds i8, i8* %15, i64 %141
br label %17
148: ; preds = %104
%149 = load i8, i8* %15
%150 = add nsw i32 %12, 1
%151 = sext i32 %12 to i64
%152 = getelementptr inbounds i8, i8* %8, i64 %151
store i8 %149, i8* %152
br label %17
153: ; preds = %14, %14
%154 = getelementptr inbounds i8, i8* %11, i64 2
%155 = load i8, i8* %154
%156 = call i32 @isxdigit(i8 zeroext %155)
%157 = icmp eq i32 %156, 0
br i1 %157, label %199, label %158
158: ; preds = %153, %166
%159 = phi i64 [ %161, %166 ], [ 0, %153 ]
%160 = phi i32 [ %177, %166 ], [ 0, %153 ]
%161 = add nuw nsw i64 %159, 1
%162 = getelementptr inbounds i8, i8* %15, i64 %161
%163 = load i8, i8* %162
%164 = call i32 @isxdigit(i8 zeroext %163)
%165 = icmp eq i32 %164, 0
br i1 %165, label %182, label %166
166: ; preds = %158
%167 = shl i32 %160, 4
%168 = load i8, i8* %162
%169 = zext i8 %168 to i32
%170 = add i8 %168, -97
%171 = icmp ult i8 %170, 6
%172 = add i8 %168, -65
%173 = icmp ult i8 %172, 6
%174 = select i1 %173, i32 -55, i32 -48
%175 = select i1 %171, i32 -87, i32 %174
%176 = add nsw i32 %175, %169
%177 = add i32 %176, %167
%178 = load i8, i8* %15
%179 = icmp eq i8 %178, 117
%180 = select i1 %179, i64 4, i64 8
%181 = icmp ult i64 %161, %180
br i1 %181, label %158, label %182
182: ; preds = %166, %158
%183 = phi i64 [ %161, %166 ], [ %159, %158 ]
%184 = phi i32 [ %177, %166 ], [ %160, %158 ]
%185 = call i32 @utf8_int_string(i32 %184, i8* %3)
%186 = load i8, i8* %3
%187 = icmp eq i8 %186, 0
br i1 %187, label %194, label %188
188: ; preds = %182
%189 = call i32 @strlen(i8* %3)
%190 = sext i32 %12 to i64
%191 = getelementptr inbounds i8, i8* %8, i64 %190
%192 = call i32 @memcpy(i8* %191, i8* %3, i32 %189)
%193 = add nsw i32 %189, %12
br label %194
194: ; preds = %188, %182
%195 = phi i32 [ %193, %188 ], [ %12, %182 ]
%196 = add i64 %183, 1
%197 = and i64 %196, 4294967295
%198 = getelementptr inbounds i8, i8* %15, i64 %197
br label %17
199: ; preds = %153
%200 = load i8, i8* %15
%201 = add nsw i32 %12, 1
%202 = sext i32 %12 to i64
%203 = getelementptr inbounds i8, i8* %8, i64 %202
store i8 %200, i8* %203
br label %17
204: ; preds = %14
%205 = add nsw i32 %12, 1
%206 = sext i32 %12 to i64
%207 = getelementptr inbounds i8, i8* %8, i64 %206
store i8 92, i8* %207
%208 = load i8, i8* %15
%209 = add nsw i32 %12, 2
%210 = sext i32 %205 to i64
%211 = getelementptr inbounds i8, i8* %8, i64 %210
store i8 %208, i8* %211
%212 = getelementptr inbounds i8, i8* %11, i64 2
br label %17
213: ; preds = %10
%214 = add nsw i32 %12, 1
%215 = sext i32 %12 to i64
%216 = getelementptr inbounds i8, i8* %8, i64 %215
store i8 %13, i8* %216
%217 = getelementptr inbounds i8, i8* %11, i64 1
br label %17
218: ; preds = %10
%219 = sext i32 %12 to i64
%220 = getelementptr inbounds i8, i8* %8, i64 %219
store i8 0, i8* %220
br label %221
221: ; preds = %5, %1, %218
%222 = phi i8* [ %8, %218 ], [ null, %1 ], [ null, %5 ]
ret i8* %222
}