#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 */
typedef char uint_fast8_t;
typedef int uint_fast32_t;
struct syntree {
  int dummy;
};

/* Variables and functions */
int /*<<< orphan*/ parse_error(char *, uintptr_t, char *);
struct syntree *range_syntree(char, char);
uintptr_t escaped_syntree(char *re, uintptr_t len, uintptr_t begin,
                          struct syntree **result) {
  if (begin >= len) {
    parse_error(re, begin - 1, "Incomplete escape sequence");
  }
  uint_fast8_t ch;
  uintptr_t end = begin;
  switch (re[begin]) {
  case '(':
  case ')':
  case '|':
  case '?':
  case '*':
  case '+':
  case '{':
  case '}':
  case '[':
  case ']':
  case '.':
  case '\\':
  case '\'':
  case '"':
  case '^':
  case '$':
    ch = re[begin];
    break;
  case 'a':
    ch = 7;
    break;
  case 'b':
    ch = 8;
    break;
  case 'f':
    ch = 12;
    break;
  case 'n':
    ch = 10;
    break;
  case 'r':
    ch = 13;
    break;
  case 't':
    ch = 9;
    break;
  case 'v':
    ch = 11;
    break;
  case 'x':
    end = begin + 2;
    if (end >= len) {
      parse_error(re, begin, "Incomplete hexadecimal escape sequence");
    }
    {
      uint_fast32_t code = 0;
      uintptr_t i;
      for (i = 1; i < 3; ++i) {
        uint_fast8_t c = re[begin + i];
        if (c >= '0' && c <= '9') {
          c -= '0';
        } else if (c >= 'a' && c <= 'f') {
          c -= 'a' - 10;
        } else if (c >= 'A' && c <= 'F') {
          c -= 'A' - 10;
        } else {
          parse_error(re, begin + i,
                      "Invalid character in hexadecimal "
                      "escape sequence");
        }
        code *= 16;
        code += c;
      }
      if (code > 127) {
        parse_error(re, begin, "Escaped non-ASCII character");
      }
      ch = code;
    }
    break;
  case '0':
  case '1':
  case '2':
  case '3':
  case '4':
  case '5':
  case '6':
  case '7':
  case '8':
  case '9':
    end = begin + 2;
    if (end >= len) {
      parse_error(re, begin, "Incomplete octal escape sequence");
    }
    {
      uint_fast32_t code = 0;
      uintptr_t i;
      for (i = 0; i < 3; ++i) {
        uint_fast8_t c = re[begin + i];
        if (c < '0' || c > '7') {
          parse_error(re, begin + i,
                      "Invalid character in octal "
                      "escape sequence");
        }
        code *= 8;
        code += c - '0';
      }
      if (code > 127) {
        parse_error(re, begin, "Escaped non-ASCII character");
      }
      ch = code;
    }
    break;
  default:
    parse_error(re, begin, "Unknown escape sequence");
  }
  *result = range_syntree(ch, ch);
  return end;
}


x86 assembly (clang, -O0):
<escaped_syntree>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     115e <escaped_syntree+0x3e>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
sub    $0x1,%rsi
lea    0x1017(%rip),%rdx
call   1030 <parse_error@plt>
mov    -0x18(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
add    $0xffffffde,%eax
mov    %eax,%ecx
mov    %rcx,-0x60(%rbp)
sub    $0x5b,%eax
ja     140a <escaped_syntree+0x2ea>
mov    -0x60(%rbp),%rax
lea    0xe71(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x21(%rbp)
jmp    141e <escaped_syntree+0x2fe>
movb   $0x7,-0x21(%rbp)
jmp    141e <escaped_syntree+0x2fe>
movb   $0x8,-0x21(%rbp)
jmp    141e <escaped_syntree+0x2fe>
movb   $0xc,-0x21(%rbp)
jmp    141e <escaped_syntree+0x2fe>
movb   $0xa,-0x21(%rbp)
jmp    141e <escaped_syntree+0x2fe>
movb   $0xd,-0x21(%rbp)
jmp    141e <escaped_syntree+0x2fe>
movb   $0x9,-0x21(%rbp)
jmp    141e <escaped_syntree+0x2fe>
movb   $0xb,-0x21(%rbp)
jmp    141e <escaped_syntree+0x2fe>
mov    -0x18(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1218 <escaped_syntree+0xf8>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
lea    0xf78(%rip),%rdx
call   1030 <parse_error@plt>
movl   $0x0,-0x34(%rbp)
movq   $0x1,-0x40(%rbp)
cmpq   $0x3,-0x40(%rbp)
jae    1305 <escaped_syntree+0x1e5>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    -0x40(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x41(%rbp)
movsbl -0x41(%rbp),%eax
cmp    $0x30,%eax
jl     126d <escaped_syntree+0x14d>
movsbl -0x41(%rbp),%eax
cmp    $0x39,%eax
jg     126d <escaped_syntree+0x14d>
movsbl -0x41(%rbp),%eax
sub    $0x30,%eax
mov    %al,-0x41(%rbp)
jmp    12e1 <escaped_syntree+0x1c1>
movsbl -0x41(%rbp),%eax
cmp    $0x61,%eax
jl     1296 <escaped_syntree+0x176>
movsbl -0x41(%rbp),%eax
cmp    $0x66,%eax
jg     1296 <escaped_syntree+0x176>
movsbl -0x41(%rbp),%eax
sub    $0x57,%eax
mov    %al,-0x41(%rbp)
jmp    12dc <escaped_syntree+0x1bc>
movsbl -0x41(%rbp),%eax
cmp    $0x41,%eax
jl     12bf <escaped_syntree+0x19f>
movsbl -0x41(%rbp),%eax
cmp    $0x46,%eax
jg     12bf <escaped_syntree+0x19f>
movsbl -0x41(%rbp),%eax
sub    $0x37,%eax
mov    %al,-0x41(%rbp)
jmp    12d7 <escaped_syntree+0x1b7>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
add    -0x40(%rbp),%rsi
lea    0xee0(%rip),%rdx
call   1030 <parse_error@plt>
jmp    12dc <escaped_syntree+0x1bc>
jmp    12e1 <escaped_syntree+0x1c1>
mov    -0x34(%rbp),%eax
shl    $0x4,%eax
mov    %eax,-0x34(%rbp)
movsbl -0x41(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1227 <escaped_syntree+0x107>
cmpl   $0x7f,-0x34(%rbp)
jle    1323 <escaped_syntree+0x203>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
lea    0xec5(%rip),%rdx
call   1030 <parse_error@plt>
mov    -0x34(%rbp),%eax
mov    %al,-0x21(%rbp)
jmp    141e <escaped_syntree+0x2fe>
mov    -0x18(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     135c <escaped_syntree+0x23c>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
lea    0xea8(%rip),%rdx
call   1030 <parse_error@plt>
movl   $0x0,-0x48(%rbp)
movq   $0x0,-0x50(%rbp)
cmpq   $0x3,-0x50(%rbp)
jae    13e1 <escaped_syntree+0x2c1>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    -0x50(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x51(%rbp)
movsbl -0x51(%rbp),%eax
cmp    $0x30,%eax
jl     13a2 <escaped_syntree+0x282>
movsbl -0x51(%rbp),%eax
cmp    $0x37,%eax
jle    13ba <escaped_syntree+0x29a>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
add    -0x50(%rbp),%rsi
lea    0xe6b(%rip),%rdx
call   1030 <parse_error@plt>
mov    -0x48(%rbp),%eax
shl    $0x3,%eax
mov    %eax,-0x48(%rbp)
movsbl -0x51(%rbp),%eax
sub    $0x30,%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    136b <escaped_syntree+0x24b>
cmpl   $0x7f,-0x48(%rbp)
jle    13ff <escaped_syntree+0x2df>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
lea    0xde9(%rip),%rdx
call   1030 <parse_error@plt>
mov    -0x48(%rbp),%eax
mov    %al,-0x21(%rbp)
jmp    141e <escaped_syntree+0x2fe>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
lea    0xe32(%rip),%rdx
call   1030 <parse_error@plt>
mov    -0x21(%rbp),%al
movsbl %al,%edi
movsbl -0x21(%rbp),%esi
call   1040 <range_syntree@plt>
mov    %rax,%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x30(%rbp),%rax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<escaped_syntree>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rcx,%r12
mov    %rdx,%r13
mov    %rsi,%rbx
mov    %rdi,%r15
cmp    %rsi,%rdx
jb     114f <escaped_syntree+0x2f>
lea    -0x1(%r13),%rsi
lea    0x1029(%rip),%rdx
mov    %r15,%rdi
call   1030 <parse_error@plt>
mov    (%r15,%r13,1),%al
movsbl %al,%r14d
lea    -0x22(%r14),%ecx
cmp    $0x5b,%ecx
ja     1329 <escaped_syntree+0x209>
mov    $0x7,%bpl
lea    0xe92(%rip),%rdx
movslq (%rdx,%rcx,4),%rcx
add    %rdx,%rcx
jmp    *%rcx
mov    %eax,%ebp
jmp    122a <escaped_syntree+0x10a>
mov    %r12,(%rsp)
lea    0x2(%r13),%r12
cmp    %rbx,%r12
jb     11a5 <escaped_syntree+0x85>
lea    0x106d(%rip),%rdx
mov    %r15,%rdi
mov    %r13,%rsi
call   1030 <parse_error@plt>
mov    (%r15,%r13,1),%al
movsbl %al,%r14d
add    $0xc8,%al
cmp    $0xf7,%al
ja     11bd <escaped_syntree+0x9d>
lea    0x106e(%rip),%rdx
mov    %r15,%rdi
mov    %r13,%rsi
call   1030 <parse_error@plt>
movsbl 0x1(%r15,%r13,1),%ebx
lea    -0x38(%rbx),%eax
cmp    $0xf7,%al
ja     11dd <escaped_syntree+0xbd>
lea    0x1(%r13),%rsi
lea    0x104b(%rip),%rdx
mov    %r15,%rdi
call   1030 <parse_error@plt>
lea    (%rbx,%r14,8),%ebx
add    $0xfffffe50,%ebx
movsbl (%r15,%r12,1),%ebp
lea    -0x38(%rbp),%eax
cmp    $0xf7,%al
ja     1205 <escaped_syntree+0xe5>
lea    0x1026(%rip),%rdx
mov    %r15,%rdi
mov    %r12,%rsi
call   1030 <parse_error@plt>
lea    -0x30(%rbp,%rbx,8),%ebp
cmp    $0x80,%ebp
jl     1223 <escaped_syntree+0x103>
lea    0xfcb(%rip),%rdx
mov    %r15,%rdi
mov    %r13,%rsi
call   1030 <parse_error@plt>
mov    %r12,%r13
mov    (%rsp),%r12
movsbl %bpl,%edi
mov    %edi,%esi
call   1040 <range_syntree@plt>
mov    %rax,(%r12)
mov    %r13,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0xa,%bpl
jmp    122a <escaped_syntree+0x10a>
mov    $0xc,%bpl
jmp    122a <escaped_syntree+0x10a>
mov    $0x8,%bpl
jmp    122a <escaped_syntree+0x10a>
mov    %r12,%r14
lea    0x2(%r13),%r12
cmp    %rbx,%r12
jb     1278 <escaped_syntree+0x158>
lea    0xf1e(%rip),%rdx
mov    %r15,%rdi
mov    %r13,%rsi
call   1030 <parse_error@plt>
mov    0x1(%r15,%r13,1),%bl
lea    -0x30(%rbx),%eax
cmp    $0xa,%al
jb     12c0 <escaped_syntree+0x1a0>
lea    -0x61(%rbx),%eax
cmp    $0x5,%al
ja     129f <escaped_syntree+0x17f>
add    $0xa9,%bl
jmp    12be <escaped_syntree+0x19e>
mov    $0xd,%bpl
jmp    122a <escaped_syntree+0x10a>
mov    $0x9,%bpl
jmp    122a <escaped_syntree+0x10a>
mov    $0xb,%bpl
jmp    122a <escaped_syntree+0x10a>
lea    -0x41(%rbx),%eax
cmp    $0x5,%al
ja     12ab <escaped_syntree+0x18b>
add    $0xc9,%bl
jmp    12be <escaped_syntree+0x19e>
lea    0x1(%r13),%rsi
lea    0xefc(%rip),%rdx
mov    %r15,%rdi
call   1030 <parse_error@plt>
mov    %ebx,%eax
movsbl %al,%ebx
mov    (%r15,%r12,1),%bpl
lea    -0x30(%rbp),%eax
cmp    $0xa,%al
jb     12fc <escaped_syntree+0x1dc>
lea    -0x61(%rbp),%eax
cmp    $0x6,%al
jae    12db <escaped_syntree+0x1bb>
add    $0xa9,%bpl
jmp    12fa <escaped_syntree+0x1da>
lea    -0x41(%rbp),%eax
cmp    $0x6,%al
jae    12e8 <escaped_syntree+0x1c8>
add    $0xc9,%bpl
jmp    12fa <escaped_syntree+0x1da>
lea    0xec3(%rip),%rdx
mov    %r15,%rdi
mov    %r12,%rsi
call   1030 <parse_error@plt>
mov    %ebp,%eax
shl    $0x4,%ebx
movsbl %al,%ebp
add    %ebx,%ebp
cmp    $0x80,%ebp
jl     131e <escaped_syntree+0x1fe>
lea    0xed0(%rip),%rdx
mov    %r15,%rdi
mov    %r13,%rsi
call   1030 <parse_error@plt>
mov    %r12,%r13
mov    %r14,%r12
jmp    122a <escaped_syntree+0x10a>
lea    0xf1b(%rip),%rdx
mov    %r15,%rdi
mov    %r13,%rsi
call   1030 <parse_error@plt>

LLVM IR (-O0):
%struct.syntree = type { i32 }
@.str = [27 x i8] c"Incomplete escape sequence\00"
@.str.1 = [39 x i8] c"Incomplete hexadecimal escape sequence\00"
@.str.2 = [49 x i8] c"Invalid character in hexadecimal escape sequence\00"
@.str.3 = [28 x i8] c"Escaped non-ASCII character\00"
@.str.4 = [33 x i8] c"Incomplete octal escape sequence\00"
@.str.5 = [43 x i8] c"Invalid character in octal escape sequence\00"
@.str.6 = [24 x i8] c"Unknown escape sequence\00"
define i64 @escaped_syntree(i8* %0, i64 %1, i64 %2, %struct.syntree** %3) {
%5 = alloca i8*
%6 = alloca i64
%7 = alloca i64
%8 = alloca %struct.syntree**
%9 = alloca i8
%10 = alloca i64
%11 = alloca i32
%12 = alloca i64
%13 = alloca i8
%14 = alloca i32
%15 = alloca i64
%16 = alloca i8
store i8* %0, i8** %5
store i64 %1, i64* %6
store i64 %2, i64* %7
store %struct.syntree** %3, %struct.syntree*** %8
%17 = load i64, i64* %7
%18 = load i64, i64* %6
%19 = icmp uge i64 %17, %18
br i1 %19, label %20, label %25
20: ; preds = %4
%21 = load i8*, i8** %5
%22 = load i64, i64* %7
%23 = sub i64 %22, 1
%24 = call i32 @parse_error(i8* %21, i64 %23, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str, i64 0, i64 0))
br label %25
25: ; preds = %20, %4
%26 = load i64, i64* %7
store i64 %26, i64* %10
%27 = load i8*, i8** %5
%28 = load i64, i64* %7
%29 = getelementptr inbounds i8, i8* %27, i64 %28
%30 = load i8, i8* %29
%31 = sext i8 %30 to i32
switch i32 %31, label %186 [
i32 40, label %32
i32 41, label %32
i32 124, label %32
i32 63, label %32
i32 42, label %32
i32 43, label %32
i32 123, label %32
i32 125, label %32
i32 91, label %32
i32 93, label %32
i32 46, label %32
i32 92, label %32
i32 39, label %32
i32 34, label %32
i32 94, label %32
i32 36, label %32
i32 97, label %37
i32 98, label %38
i32 102, label %39
i32 110, label %40
i32 114, label %41
i32 116, label %42
i32 118, label %43
i32 120, label %44
i32 48, label %131
i32 49, label %131
i32 50, label %131
i32 51, label %131
i32 52, label %131
i32 53, label %131
i32 54, label %131
i32 55, label %131
i32 56, label %131
i32 57, label %131
]
32: ; preds = %25, %25, %25, %25, %25, %25, %25, %25, %25, %25, %25, %25, %25, %25, %25, %25
%33 = load i8*, i8** %5
%34 = load i64, i64* %7
%35 = getelementptr inbounds i8, i8* %33, i64 %34
%36 = load i8, i8* %35
store i8 %36, i8* %9
br label %190
37: ; preds = %25
store i8 7, i8* %9
br label %190
38: ; preds = %25
store i8 8, i8* %9
br label %190
39: ; preds = %25
store i8 12, i8* %9
br label %190
40: ; preds = %25
store i8 10, i8* %9
br label %190
41: ; preds = %25
store i8 13, i8* %9
br label %190
42: ; preds = %25
store i8 9, i8* %9
br label %190
43: ; preds = %25
store i8 11, i8* %9
br label %190
44: ; preds = %25
%45 = load i64, i64* %7
%46 = add i64 %45, 2
store i64 %46, i64* %10
%47 = load i64, i64* %10
%48 = load i64, i64* %6
%49 = icmp uge i64 %47, %48
br i1 %49, label %50, label %54
50: ; preds = %44
%51 = load i8*, i8** %5
%52 = load i64, i64* %7
%53 = call i32 @parse_error(i8* %51, i64 %52, i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.1, i64 0, i64 0))
br label %54
54: ; preds = %50, %44
store i32 0, i32* %11
store i64 1, i64* %12
br label %55
55: ; preds = %118, %54
%56 = load i64, i64* %12
%57 = icmp ult i64 %56, 3
br i1 %57, label %58, label %121
58: ; preds = %55
%59 = load i8*, i8** %5
%60 = load i64, i64* %7
%61 = load i64, i64* %12
%62 = add i64 %60, %61
%63 = getelementptr inbounds i8, i8* %59, i64 %62
%64 = load i8, i8* %63
store i8 %64, i8* %13
%65 = load i8, i8* %13
%66 = sext i8 %65 to i32
%67 = icmp sge i32 %66, 48
br i1 %67, label %68, label %77
68: ; preds = %58
%69 = load i8, i8* %13
%70 = sext i8 %69 to i32
%71 = icmp sle i32 %70, 57
br i1 %71, label %72, label %77
72: ; preds = %68
%73 = load i8, i8* %13
%74 = sext i8 %73 to i32
%75 = sub nsw i32 %74, 48
%76 = trunc i32 %75 to i8
store i8 %76, i8* %13
br label %111
77: ; preds = %68, %58
%78 = load i8, i8* %13
%79 = sext i8 %78 to i32
%80 = icmp sge i32 %79, 97
br i1 %80, label %81, label %90
81: ; preds = %77
%82 = load i8, i8* %13
%83 = sext i8 %82 to i32
%84 = icmp sle i32 %83, 102
br i1 %84, label %85, label %90
85: ; preds = %81
%86 = load i8, i8* %13
%87 = sext i8 %86 to i32
%88 = sub nsw i32 %87, 87
%89 = trunc i32 %88 to i8
store i8 %89, i8* %13
br label %110
90: ; preds = %81, %77
%91 = load i8, i8* %13
%92 = sext i8 %91 to i32
%93 = icmp sge i32 %92, 65
br i1 %93, label %94, label %103
94: ; preds = %90
%95 = load i8, i8* %13
%96 = sext i8 %95 to i32
%97 = icmp sle i32 %96, 70
br i1 %97, label %98, label %103
98: ; preds = %94
%99 = load i8, i8* %13
%100 = sext i8 %99 to i32
%101 = sub nsw i32 %100, 55
%102 = trunc i32 %101 to i8
store i8 %102, i8* %13
br label %109
103: ; preds = %94, %90
%104 = load i8*, i8** %5
%105 = load i64, i64* %7
%106 = load i64, i64* %12
%107 = add i64 %105, %106
%108 = call i32 @parse_error(i8* %104, i64 %107, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.2, i64 0, i64 0))
br label %109
109: ; preds = %103, %98
br label %110
110: ; preds = %109, %85
br label %111
111: ; preds = %110, %72
%112 = load i32, i32* %11
%113 = mul nsw i32 %112, 16
store i32 %113, i32* %11
%114 = load i8, i8* %13
%115 = sext i8 %114 to i32
%116 = load i32, i32* %11
%117 = add nsw i32 %116, %115
store i32 %117, i32* %11
br label %118
118: ; preds = %111
%119 = load i64, i64* %12
%120 = add i64 %119, 1
store i64 %120, i64* %12
br label %55
121: ; preds = %55
%122 = load i32, i32* %11
%123 = icmp sgt i32 %122, 127
br i1 %123, label %124, label %128
124: ; preds = %121
%125 = load i8*, i8** %5
%126 = load i64, i64* %7
%127 = call i32 @parse_error(i8* %125, i64 %126, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.3, i64 0, i64 0))
br label %128
128: ; preds = %124, %121
%129 = load i32, i32* %11
%130 = trunc i32 %129 to i8
store i8 %130, i8* %9
br label %190
131: ; preds = %25, %25, %25, %25, %25, %25, %25, %25, %25, %25
%132 = load i64, i64* %7
%133 = add i64 %132, 2
store i64 %133, i64* %10
%134 = load i64, i64* %10
%135 = load i64, i64* %6
%136 = icmp uge i64 %134, %135
br i1 %136, label %137, label %141
137: ; preds = %131
%138 = load i8*, i8** %5
%139 = load i64, i64* %7
%140 = call i32 @parse_error(i8* %138, i64 %139, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.4, i64 0, i64 0))
br label %141
141: ; preds = %137, %131
store i32 0, i32* %14
store i64 0, i64* %15
br label %142
142: ; preds = %173, %141
%143 = load i64, i64* %15
%144 = icmp ult i64 %143, 3
br i1 %144, label %145, label %176
145: ; preds = %142
%146 = load i8*, i8** %5
%147 = load i64, i64* %7
%148 = load i64, i64* %15
%149 = add i64 %147, %148
%150 = getelementptr inbounds i8, i8* %146, i64 %149
%151 = load i8, i8* %150
store i8 %151, i8* %16
%152 = load i8, i8* %16
%153 = sext i8 %152 to i32
%154 = icmp slt i32 %153, 48
br i1 %154, label %159, label %155
155: ; preds = %145
%156 = load i8, i8* %16
%157 = sext i8 %156 to i32
%158 = icmp sgt i32 %157, 55
br i1 %158, label %159, label %165
159: ; preds = %155, %145
%160 = load i8*, i8** %5
%161 = load i64, i64* %7
%162 = load i64, i64* %15
%163 = add i64 %161, %162
%164 = call i32 @parse_error(i8* %160, i64 %163, i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.5, i64 0, i64 0))
br label %165
165: ; preds = %159, %155
%166 = load i32, i32* %14
%167 = mul nsw i32 %166, 8
store i32 %167, i32* %14
%168 = load i8, i8* %16
%169 = sext i8 %168 to i32
%170 = sub nsw i32 %169, 48
%171 = load i32, i32* %14
%172 = add nsw i32 %171, %170
store i32 %172, i32* %14
br label %173
173: ; preds = %165
%174 = load i64, i64* %15
%175 = add i64 %174, 1
store i64 %175, i64* %15
br label %142
176: ; preds = %142
%177 = load i32, i32* %14
%178 = icmp sgt i32 %177, 127
br i1 %178, label %179, label %183
179: ; preds = %176
%180 = load i8*, i8** %5
%181 = load i64, i64* %7
%182 = call i32 @parse_error(i8* %180, i64 %181, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.3, i64 0, i64 0))
br label %183
183: ; preds = %179, %176
%184 = load i32, i32* %14
%185 = trunc i32 %184 to i8
store i8 %185, i8* %9
br label %190
186: ; preds = %25
%187 = load i8*, i8** %5
%188 = load i64, i64* %7
%189 = call i32 @parse_error(i8* %187, i64 %188, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.6, i64 0, i64 0))
br label %190
190: ; preds = %186, %183, %128, %43, %42, %41, %40, %39, %38, %37, %32
%191 = load i8, i8* %9
%192 = load i8, i8* %9
%193 = call %struct.syntree* @range_syntree(i8 signext %191, i8 signext %192)
%194 = load %struct.syntree**, %struct.syntree*** %8
store %struct.syntree* %193, %struct.syntree** %194
%195 = load i64, i64* %10
ret i64 %195
}

LLVM IR (-O2):
%struct.syntree = type { i32 }
@.str = [27 x i8] c"Incomplete escape sequence\00"
@.str.1 = [39 x i8] c"Incomplete hexadecimal escape sequence\00"
@.str.2 = [49 x i8] c"Invalid character in hexadecimal escape sequence\00"
@.str.3 = [28 x i8] c"Escaped non-ASCII character\00"
@.str.4 = [33 x i8] c"Incomplete octal escape sequence\00"
@.str.5 = [43 x i8] c"Invalid character in octal escape sequence\00"
@.str.6 = [24 x i8] c"Unknown escape sequence\00"
define i64 @escaped_syntree(i8* %0, i64 %1, i64 %2, %struct.syntree** nocapture writeonly %3) {
%5 = icmp ult i64 %2, %1
br i1 %5, label %9, label %6
6: ; preds = %4
%7 = add i64 %2, -1
%8 = tail call i32 @parse_error(i8* %0, i64 %7, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str, i64 0, i64 0))
br label %9
9: ; preds = %6, %4
%10 = getelementptr inbounds i8, i8* %0, i64 %2
%11 = load i8, i8* %10
%12 = sext i8 %11 to i32
switch i32 %12, label %115 [
i32 40, label %13
i32 41, label %13
i32 124, label %13
i32 63, label %13
i32 42, label %13
i32 43, label %13
i32 123, label %13
i32 125, label %13
i32 91, label %13
i32 93, label %13
i32 46, label %13
i32 92, label %13
i32 39, label %13
i32 34, label %13
i32 94, label %13
i32 36, label %13
i32 97, label %117
i32 98, label %14
i32 102, label %15
i32 110, label %16
i32 114, label %17
i32 116, label %18
i32 118, label %19
i32 120, label %20
i32 48, label %72
i32 49, label %72
i32 50, label %72
i32 51, label %72
i32 52, label %72
i32 53, label %72
i32 54, label %72
i32 55, label %72
i32 56, label %72
i32 57, label %72
]
13: ; preds = %9, %9, %9, %9, %9, %9, %9, %9, %9, %9, %9, %9, %9, %9, %9, %9
br label %117
14: ; preds = %9
br label %117
15: ; preds = %9
br label %117
16: ; preds = %9
br label %117
17: ; preds = %9
br label %117
18: ; preds = %9
br label %117
19: ; preds = %9
br label %117
20: ; preds = %9
%21 = add i64 %2, 2
%22 = icmp ult i64 %21, %1
br i1 %22, label %25, label %23
23: ; preds = %20
%24 = tail call i32 @parse_error(i8* %0, i64 %2, i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.1, i64 0, i64 0))
br label %25
25: ; preds = %23, %20
%26 = add i64 %2, 1
%27 = getelementptr inbounds i8, i8* %0, i64 %26
%28 = load i8, i8* %27
%29 = add i8 %28, -48
%30 = icmp ult i8 %29, 10
br i1 %30, label %43, label %31
31: ; preds = %25
%32 = add i8 %28, -97
%33 = icmp ult i8 %32, 6
br i1 %33, label %34, label %36
34: ; preds = %31
%35 = add nsw i8 %28, -87
br label %43
36: ; preds = %31
%37 = add i8 %28, -65
%38 = icmp ult i8 %37, 6
br i1 %38, label %39, label %41
39: ; preds = %36
%40 = add nsw i8 %28, -55
br label %43
41: ; preds = %36
%42 = tail call i32 @parse_error(i8* %0, i64 %26, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.2, i64 0, i64 0))
br label %43
43: ; preds = %25, %34, %41, %39
%44 = phi i8 [ %35, %34 ], [ %40, %39 ], [ %28, %41 ], [ %29, %25 ]
%45 = sext i8 %44 to i32
%46 = getelementptr inbounds i8, i8* %0, i64 %21
%47 = load i8, i8* %46
%48 = add i8 %47, -48
%49 = icmp ult i8 %48, 10
br i1 %49, label %62, label %50
50: ; preds = %43
%51 = add i8 %47, -97
%52 = icmp ult i8 %51, 6
br i1 %52, label %60, label %53
53: ; preds = %50
%54 = add i8 %47, -65
%55 = icmp ult i8 %54, 6
br i1 %55, label %58, label %56
56: ; preds = %53
%57 = tail call i32 @parse_error(i8* %0, i64 %21, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.2, i64 0, i64 0))
br label %62
58: ; preds = %53
%59 = add nsw i8 %47, -55
br label %62
60: ; preds = %50
%61 = add nsw i8 %47, -87
br label %62
62: ; preds = %60, %58, %56, %43
%63 = phi i8 [ %61, %60 ], [ %59, %58 ], [ %47, %56 ], [ %48, %43 ]
%64 = shl nsw i32 %45, 4
%65 = sext i8 %63 to i32
%66 = add nsw i32 %64, %65
%67 = icmp sgt i32 %66, 127
br i1 %67, label %68, label %70
68: ; preds = %62
%69 = tail call i32 @parse_error(i8* %0, i64 %2, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.3, i64 0, i64 0))
br label %70
70: ; preds = %68, %62
%71 = trunc i32 %66 to i8
br label %117
72: ; preds = %9, %9, %9, %9, %9, %9, %9, %9, %9, %9
%73 = add i64 %2, 2
%74 = icmp ult i64 %73, %1
br i1 %74, label %79, label %75
75: ; preds = %72
%76 = tail call i32 @parse_error(i8* %0, i64 %2, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.4, i64 0, i64 0))
%77 = load i8, i8* %10
%78 = sext i8 %77 to i32
br label %79
79: ; preds = %75, %72
%80 = phi i32 [ %78, %75 ], [ %12, %72 ]
%81 = phi i8 [ %77, %75 ], [ %11, %72 ]
%82 = add i8 %81, -56
%83 = icmp ult i8 %82, -8
br i1 %83, label %84, label %86
84: ; preds = %79
%85 = tail call i32 @parse_error(i8* %0, i64 %2, i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.5, i64 0, i64 0))
br label %86
86: ; preds = %79, %84
%87 = add i64 %2, 1
%88 = getelementptr inbounds i8, i8* %0, i64 %87
%89 = load i8, i8* %88
%90 = sext i8 %89 to i32
%91 = add i8 %89, -56
%92 = icmp ult i8 %91, -8
br i1 %92, label %93, label %95
93: ; preds = %86
%94 = tail call i32 @parse_error(i8* %0, i64 %87, i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.5, i64 0, i64 0))
br label %95
95: ; preds = %93, %86
%96 = shl nsw i32 %80, 3
%97 = add nsw i32 %96, -432
%98 = add nsw i32 %97, %90
%99 = getelementptr inbounds i8, i8* %0, i64 %73
%100 = load i8, i8* %99
%101 = sext i8 %100 to i32
%102 = add i8 %100, -56
%103 = icmp ult i8 %102, -8
br i1 %103, label %104, label %106
104: ; preds = %95
%105 = tail call i32 @parse_error(i8* %0, i64 %73, i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.5, i64 0, i64 0))
br label %106
106: ; preds = %104, %95
%107 = shl nsw i32 %98, 3
%108 = add nsw i32 %107, -48
%109 = add i32 %108, %101
%110 = icmp sgt i32 %109, 127
br i1 %110, label %111, label %113
111: ; preds = %106
%112 = tail call i32 @parse_error(i8* %0, i64 %2, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.3, i64 0, i64 0))
br label %113
113: ; preds = %111, %106
%114 = trunc i32 %109 to i8
br label %117
115: ; preds = %9
%116 = tail call i32 @parse_error(i8* %0, i64 %2, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.6, i64 0, i64 0))
unreachable
117: ; preds = %9, %113, %70, %19, %18, %17, %16, %15, %14, %13
%118 = phi i64 [ %73, %113 ], [ %21, %70 ], [ %2, %19 ], [ %2, %18 ], [ %2, %17 ], [ %2, %16 ], [ %2, %15 ], [ %2, %14 ], [ %2, %13 ], [ %2, %9 ]
%119 = phi i8 [ %114, %113 ], [ %71, %70 ], [ 11, %19 ], [ 9, %18 ], [ 13, %17 ], [ 10, %16 ], [ 12, %15 ], [ 8, %14 ], [ %11, %13 ], [ 7, %9 ]
%120 = tail call %struct.syntree* @range_syntree(i8 signext %119, i8 signext %119)
store %struct.syntree* %120, %struct.syntree** %3
ret i64 %118
}