#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 scalar_t__ uint_fast8_t;
struct syntree {
  int dummy;
};

/* Variables and functions */
struct syntree *alternation(struct syntree *, struct syntree *);
int /*<<< orphan*/ parse_error(char *, uintptr_t, char *);
struct syntree *range_syntree(uintptr_t, uintptr_t);
uintptr_t class_syntree(char *re, uintptr_t len, uintptr_t i,
                        struct syntree **result) {
  if (i + 1 >= len) {
    parse_error(re, i, "Unmatched \"[\"");
  }
  ++i;
  uintptr_t begin = i;
  while (i == begin || re[i] != ']' || (re[begin] == '^' && i == begin + 1)) {
    ++i;
    if (i >= len) {
      parse_error(re, begin - 1, "Unmatched \"[\"");
    }
  }
  uintptr_t end = i;
  bool invert = false;
  if (re[begin] == '^') {
    invert = true;
    ++begin;
  }
  uintptr_t j;
  bool in_class[(127 + 1) + 1] = {0};
  for (j = begin; j < end; ++j) {
    uint_fast8_t ch = re[j];
    if (j + 2 < end && re[j + 1] == '-') {
      j += 2;
      uint_fast8_t ch2 = re[j];
      if (ch2 < ch)
        parse_error(re, j - 1, "Invalid range");
      while (ch <= ch2) {
        in_class[(uintptr_t)ch] = true;
        ++ch;
      }
    } else {
      in_class[(uintptr_t)ch] = true;
    }
  }
  in_class[(127 + 1)] = invert;
  *result = 0;
  uintptr_t range_start = 0;
  bool prev_in_class = false;
  for (j = 0; j < (127 + 1) + 1; ++j) {
    if (in_class[j] != invert) {
      if (!prev_in_class) {
        prev_in_class = true;
        range_start = j;
      }
    } else {
      if (prev_in_class) {
        struct syntree *part = range_syntree(range_start, j - 1);
        if (*result) {
          *result = alternation(*result, part);
        } else {
          *result = part;
        }
        prev_in_class = false;
      }
    }
  }
  return end;
}


x86 assembly (clang, -O0):
<class_syntree>:
push   %rbp
mov    %rsp,%rbp
sub    $0x280,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
cmp    -0x10(%rbp),%rax
jb     1181 <class_syntree+0x41>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
lea    0xe84(%rip),%rdx
call   1050 <parse_error@plt>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rcx
mov    $0x1,%al
cmp    -0x28(%rbp),%rcx
mov    %al,-0x279(%rbp)
je     1209 <class_syntree+0xc9>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    $0x1,%al
cmp    $0x5d,%ecx
mov    %al,-0x279(%rbp)
jne    1209 <class_syntree+0xc9>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x5e,%ecx
mov    %al,-0x27a(%rbp)
jne    11fd <class_syntree+0xbd>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
add    $0x1,%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x27a(%rbp)
mov    -0x27a(%rbp),%al
mov    %al,-0x279(%rbp)
mov    -0x279(%rbp),%al
test   $0x1,%al
jne    121c <class_syntree+0xdc>
jmp    1253 <class_syntree+0x113>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     124e <class_syntree+0x10e>
mov    -0x8(%rbp),%rdi
mov    -0x28(%rbp),%rsi
sub    $0x1,%rsi
lea    0xdb7(%rip),%rdx
call   1050 <parse_error@plt>
jmp    1195 <class_syntree+0x55>
mov    -0x18(%rbp),%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5e,%eax
jne    128a <class_syntree+0x14a>
movl   $0x1,-0x34(%rbp)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
lea    -0x250(%rbp),%rdi
xor    %esi,%esi
mov    $0x204,%edx
call   1040 <memset@plt>
mov    -0x28(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x30(%rbp),%rax
jae    13aa <class_syntree+0x26a>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsbq (%rax,%rcx,1),%rax
mov    %rax,-0x258(%rbp)
mov    -0x40(%rbp),%rax
add    $0x2,%rax
cmp    -0x30(%rbp),%rax
jae    1382 <class_syntree+0x242>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsbl 0x1(%rax,%rcx,1),%eax
cmp    $0x2d,%eax
jne    1382 <class_syntree+0x242>
mov    -0x40(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsbq (%rax,%rcx,1),%rax
mov    %rax,-0x260(%rbp)
mov    -0x260(%rbp),%rax
cmp    -0x258(%rbp),%rax
jge    133b <class_syntree+0x1fb>
mov    -0x8(%rbp),%rdi
mov    -0x40(%rbp),%rsi
sub    $0x1,%rsi
lea    0xcd8(%rip),%rdx
call   1050 <parse_error@plt>
jmp    1340 <class_syntree+0x200>
mov    -0x258(%rbp),%rax
cmp    -0x260(%rbp),%rax
jg     137d <class_syntree+0x23d>
mov    -0x258(%rbp),%rax
movl   $0x1,-0x250(%rbp,%rax,4)
mov    -0x258(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x258(%rbp)
jmp    1340 <class_syntree+0x200>
jmp    1394 <class_syntree+0x254>
mov    -0x258(%rbp),%rax
movl   $0x1,-0x250(%rbp,%rax,4)
jmp    1399 <class_syntree+0x259>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    12a5 <class_syntree+0x165>
mov    -0x34(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movq   $0x0,(%rax)
movq   $0x0,-0x268(%rbp)
movl   $0x0,-0x26c(%rbp)
movq   $0x0,-0x40(%rbp)
cmpq   $0x81,-0x40(%rbp)
jae    14ac <class_syntree+0x36c>
mov    -0x40(%rbp),%rax
mov    -0x250(%rbp,%rax,4),%eax
cmp    -0x34(%rbp),%eax
je     1421 <class_syntree+0x2e1>
cmpl   $0x0,-0x26c(%rbp)
jne    141c <class_syntree+0x2dc>
movl   $0x1,-0x26c(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x268(%rbp)
jmp    1496 <class_syntree+0x356>
cmpl   $0x0,-0x26c(%rbp)
je     1491 <class_syntree+0x351>
mov    -0x268(%rbp),%rdi
mov    -0x40(%rbp),%rsi
sub    $0x1,%rsi
call   1060 <range_syntree@plt>
mov    %rax,-0x278(%rbp)
mov    -0x20(%rbp),%rax
cmpq   $0x0,(%rax)
je     1479 <class_syntree+0x339>
mov    -0x20(%rbp),%rax
mov    (%rax),%rdi
mov    -0x278(%rbp),%rsi
call   1030 <alternation@plt>
mov    %rax,%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
jmp    1487 <class_syntree+0x347>
mov    -0x278(%rbp),%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x26c(%rbp)
jmp    1496 <class_syntree+0x356>
jmp    149b <class_syntree+0x35b>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    13d8 <class_syntree+0x298>
mov    -0x30(%rbp),%rax
add    $0x280,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<class_syntree>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x228,%rsp
mov    %rcx,0x18(%rsp)
mov    %rdx,%rbx
mov    %rsi,%r15
mov    %rdi,%r13
lea    0x1(%rdx),%rbp
cmp    %rsi,%rbp
jb     117a <class_syntree+0x3a>
lea    0xea1(%rip),%rdx
mov    %r13,%rdi
mov    %rbx,%rsi
call   1050 <parse_error@plt>
lea    0x2(%rbx),%rax
mov    %rax,0x10(%rsp)
mov    %r13,%r14
add    %rbp,%r14
xor    %r12d,%r12d
jmp    1194 <class_syntree+0x54>
xchg   %ax,%ax
add    $0x1,%r12
test   %r12,%r12
je     11b0 <class_syntree+0x70>
cmpb   $0x5d,(%r14,%r12,1)
jne    11b0 <class_syntree+0x70>
movzbl 0x0(%r13,%rbp,1),%eax
cmp    $0x5e,%al
jne    11d1 <class_syntree+0x91>
cmp    $0x1,%r12
jne    11d1 <class_syntree+0x91>
lea    (%rbx,%r12,1),%rax
add    $0x2,%rax
cmp    %r15,%rax
jb     1190 <class_syntree+0x50>
mov    %r13,%rdi
mov    %rbx,%rsi
lea    0xe46(%rip),%rdx
call   1050 <parse_error@plt>
jmp    1190 <class_syntree+0x50>
xor    %ecx,%ecx
cmp    $0x5e,%al
sete   %cl
mov    %ecx,0xc(%rsp)
cmove  0x10(%rsp),%rbp
lea    0x20(%rsp),%rdi
xor    %r14d,%r14d
mov    $0x200,%edx
xor    %esi,%esi
call   1040 <memset@plt>
lea    (%rbx,%r12,1),%r15
add    $0x1,%r15
cmp    %r15,%rbp
jae    1349 <class_syntree+0x209>
lea    0x90(%rsp),%r12
movaps 0xdea(%rip),%xmm0
jmp    1235 <class_syntree+0xf5>
nopl   0x0(%rax,%rax,1)
movl   $0x1,0x20(%rsp,%rax,4)
add    $0x1,%rbp
cmp    %r15,%rbp
jae    1349 <class_syntree+0x209>
movsbq 0x0(%r13,%rbp,1),%rax
lea    0x2(%rbp),%rbx
cmp    %r15,%rbx
jae    1220 <class_syntree+0xe0>
cmpb   $0x2d,0x1(%r13,%rbp,1)
jne    1220 <class_syntree+0xe0>
movsbq 0x0(%r13,%rbx,1),%rcx
cmp    %al,%cl
jge    1278 <class_syntree+0x138>
add    $0x1,%rbp
mov    %r13,%rdi
mov    %rbp,%rsi
lea    0xdb7(%rip),%rdx
call   1050 <parse_error@plt>
movaps 0xd8d(%rip),%xmm0
mov    %rbx,%rbp
jmp    1228 <class_syntree+0xe8>
mov    %rcx,%r9
sub    %rax,%r9
add    $0x1,%r9
cmp    $0x8,%r9
jb     132a <class_syntree+0x1ea>
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rdx
mov    %rdx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%ebp
and    $0x3,%ebp
cmp    $0x18,%rdx
jae    12b1 <class_syntree+0x171>
xor    %esi,%esi
jmp    12f1 <class_syntree+0x1b1>
and    $0xfffffffffffffffc,%rdi
lea    (%r12,%rax,4),%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movups %xmm0,-0x70(%rdx,%rsi,4)
movups %xmm0,-0x60(%rdx,%rsi,4)
movups %xmm0,-0x50(%rdx,%rsi,4)
movups %xmm0,-0x40(%rdx,%rsi,4)
movups %xmm0,-0x30(%rdx,%rsi,4)
movups %xmm0,-0x20(%rdx,%rsi,4)
movups %xmm0,-0x10(%rdx,%rsi,4)
movups %xmm0,(%rdx,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    12c0 <class_syntree+0x180>
test   %rbp,%rbp
je     1322 <class_syntree+0x1e2>
add    %rax,%rsi
lea    (%r12,%rsi,4),%rdx
add    $0xffffffffffffffa0,%rdx
shl    $0x5,%rbp
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups %xmm0,-0x10(%rdx,%rsi,1)
movups %xmm0,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rbp
jne    1310 <class_syntree+0x1d0>
cmp    %r8,%r9
je     1341 <class_syntree+0x201>
add    %r8,%rax
add    $0xffffffffffffffff,%rax
xchg   %ax,%ax
movl   $0x1,0x24(%rsp,%rax,4)
add    $0x1,%rax
cmp    %rcx,%rax
jl     1330 <class_syntree+0x1f0>
mov    %rbx,%rbp
jmp    1228 <class_syntree+0xe8>
mov    0xc(%rsp),%ecx
mov    %ecx,0x220(%rsp)
mov    0x18(%rsp),%r13
movq   $0x0,0x0(%r13)
xor    %r12d,%r12d
xor    %ebp,%ebp
jmp    138c <class_syntree+0x24c>
nopl   0x0(%rax,%rax,1)
test   %r14d,%r14d
cmove  %rbp,%r12
mov    $0x1,%ebx
add    $0x1,%rbp
mov    %ebx,%r14d
cmp    $0x81,%rbp
je     13c0 <class_syntree+0x280>
cmp    %ecx,0x20(%rsp,%rbp,4)
jne    1370 <class_syntree+0x230>
xor    %ebx,%ebx
test   %r14d,%r14d
je     137c <class_syntree+0x23c>
lea    -0x1(%rbp),%rsi
mov    %r12,%rdi
call   1060 <range_syntree@plt>
mov    0x0(%r13),%rdi
test   %rdi,%rdi
je     13b6 <class_syntree+0x276>
mov    %rax,%rsi
call   1030 <alternation@plt>
mov    0xc(%rsp),%ecx
mov    %rax,0x0(%r13)
jmp    137c <class_syntree+0x23c>
mov    %r15,%rax
add    $0x228,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
%struct.syntree = type { i32 }
@.str = [14 x i8] c"Unmatched \22[\22\00"
@.str.1 = [14 x i8] c"Invalid range\00"
define i64 @class_syntree(i8* %0, i64 %1, i64 %2, %struct.syntree** nocapture %3) {
%5 = alloca [129 x i32]
%6 = add i64 %2, 1
%7 = icmp ult i64 %6, %1
br i1 %7, label %10, label %8
8: ; preds = %4
%9 = tail call i32 @parse_error(i8* %0, i64 %2, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i64 0, i64 0))
br label %10
10: ; preds = %8, %4
%11 = getelementptr inbounds i8, i8* %0, i64 %6
%12 = add i64 %2, 2
br label %13
13: ; preds = %30, %10
%14 = phi i64 [ %6, %10 ], [ %26, %30 ]
%15 = icmp eq i64 %14, %6
br i1 %15, label %25, label %16
16: ; preds = %13
%17 = getelementptr inbounds i8, i8* %0, i64 %14
%18 = load i8, i8* %17
%19 = icmp eq i8 %18, 93
br i1 %19, label %20, label %25
20: ; preds = %16
%21 = load i8, i8* %11
%22 = icmp eq i8 %21, 94
%23 = icmp eq i64 %14, %12
%24 = select i1 %22, i1 %23, i1 false
br i1 %24, label %25, label %31
25: ; preds = %13, %16, %20
%26 = add i64 %14, 1
%27 = icmp ult i64 %26, %1
br i1 %27, label %30, label %28
28: ; preds = %25
%29 = tail call i32 @parse_error(i8* %0, i64 %2, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i64 0, i64 0))
br label %30
30: ; preds = %28, %25
br label %13
31: ; preds = %20
%32 = zext i1 %22 to i32
%33 = select i1 %22, i64 %12, i64 %6
%34 = bitcast [129 x i32]* %5 to i8*
%35 = icmp ult i64 %33, %14
br i1 %35, label %36, label %127
36: ; preds = %31, %123
%37 = phi i64 [ %125, %123 ], [ %33, %31 ]
%38 = getelementptr inbounds i8, i8* %0, i64 %37
%39 = load i8, i8* %38
%40 = sext i8 %39 to i64
%41 = add i64 %37, 2
%42 = icmp ult i64 %41, %14
br i1 %42, label %43, label %121
43: ; preds = %36
%44 = add nuw i64 %37, 1
%45 = getelementptr inbounds i8, i8* %0, i64 %44
%46 = load i8, i8* %45
%47 = icmp eq i8 %46, 45
br i1 %47, label %48, label %121
48: ; preds = %43
%49 = getelementptr inbounds i8, i8* %0, i64 %41
%50 = load i8, i8* %49
%51 = sext i8 %50 to i64
%52 = icmp slt i8 %50, %39
br i1 %52, label %114, label %53
53: ; preds = %48
%54 = add nsw i64 %51, 1
%55 = sub nsw i64 %54, %40
%56 = icmp ult i64 %55, 8
br i1 %56, label %112, label %57
57: ; preds = %53
%58 = and i64 %55, -8
%59 = add nsw i64 %58, %40
%60 = add nsw i64 %58, -8
%61 = lshr exact i64 %60, 3
%62 = add nuw nsw i64 %61, 1
%63 = and i64 %62, 3
%64 = icmp ult i64 %60, 24
br i1 %64, label %96, label %65
65: ; preds = %57
%66 = and i64 %62, 4611686018427387900
br label %67
67: ; preds = %67, %65
%68 = phi i64 [ 0, %65 ], [ %93, %67 ]
%69 = phi i64 [ 0, %65 ], [ %94, %67 ]
%70 = add i64 %68, %40
%71 = getelementptr inbounds [129 x i32], [129 x i32]* %5, i64 0, i64 %70
%72 = bitcast i32* %71 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %72
%73 = getelementptr inbounds i32, i32* %71, i64 4
%74 = bitcast i32* %73 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %74
%75 = or i64 %68, 8
%76 = add i64 %75, %40
%77 = getelementptr inbounds [129 x i32], [129 x i32]* %5, i64 0, i64 %76
%78 = bitcast i32* %77 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %78
%79 = getelementptr inbounds i32, i32* %77, i64 4
%80 = bitcast i32* %79 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %80
%81 = or i64 %68, 16
%82 = add i64 %81, %40
%83 = getelementptr inbounds [129 x i32], [129 x i32]* %5, i64 0, i64 %82
%84 = bitcast i32* %83 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %84
%85 = getelementptr inbounds i32, i32* %83, i64 4
%86 = bitcast i32* %85 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %86
%87 = or i64 %68, 24
%88 = add i64 %87, %40
%89 = getelementptr inbounds [129 x i32], [129 x i32]* %5, i64 0, i64 %88
%90 = bitcast i32* %89 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %90
%91 = getelementptr inbounds i32, i32* %89, i64 4
%92 = bitcast i32* %91 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %92
%93 = add nuw i64 %68, 32
%94 = add i64 %69, 4
%95 = icmp eq i64 %94, %66
br i1 %95, label %96, label %67
96: ; preds = %67, %57
%97 = phi i64 [ 0, %57 ], [ %93, %67 ]
%98 = icmp eq i64 %63, 0
br i1 %98, label %110, label %99
99: ; preds = %96, %99
%100 = phi i64 [ %107, %99 ], [ %97, %96 ]
%101 = phi i64 [ %108, %99 ], [ 0, %96 ]
%102 = add i64 %100, %40
%103 = getelementptr inbounds [129 x i32], [129 x i32]* %5, i64 0, i64 %102
%104 = bitcast i32* %103 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %104
%105 = getelementptr inbounds i32, i32* %103, i64 4
%106 = bitcast i32* %105 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %106
%107 = add nuw i64 %100, 8
%108 = add i64 %101, 1
%109 = icmp eq i64 %108, %63
br i1 %109, label %110, label %99
110: ; preds = %99, %96
%111 = icmp eq i64 %55, %58
br i1 %111, label %123, label %112
112: ; preds = %53, %110
%113 = phi i64 [ %40, %53 ], [ %59, %110 ]
br label %116
114: ; preds = %48
%115 = tail call i32 @parse_error(i8* %0, i64 %44, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.1, i64 0, i64 0))
br label %123
116: ; preds = %112, %116
%117 = phi i64 [ %119, %116 ], [ %113, %112 ]
%118 = getelementptr inbounds [129 x i32], [129 x i32]* %5, i64 0, i64 %117
store i32 1, i32* %118
%119 = add nsw i64 %117, 1
%120 = icmp slt i64 %117, %51
br i1 %120, label %116, label %123
121: ; preds = %43, %36
%122 = getelementptr inbounds [129 x i32], [129 x i32]* %5, i64 0, i64 %40
store i32 1, i32* %122
br label %123
123: ; preds = %116, %110, %114, %121
%124 = phi i64 [ %37, %121 ], [ %41, %114 ], [ %41, %110 ], [ %41, %116 ]
%125 = add i64 %124, 1
%126 = icmp ult i64 %125, %14
br i1 %126, label %36, label %127
127: ; preds = %123, %31
%128 = getelementptr inbounds [129 x i32], [129 x i32]* %5, i64 0, i64 128
store i32 %32, i32* %128
store %struct.syntree* null, %struct.syntree** %3
br label %129
129: ; preds = %127, %149
%130 = phi i32 [ 0, %127 ], [ %151, %149 ]
%131 = phi i64 [ 0, %127 ], [ %150, %149 ]
%132 = phi i64 [ 0, %127 ], [ %152, %149 ]
%133 = getelementptr inbounds [129 x i32], [129 x i32]* %5, i64 0, i64 %132
%134 = load i32, i32* %133
%135 = icmp eq i32 %134, %32
%136 = icmp eq i32 %130, 0
br i1 %135, label %139, label %137
137: ; preds = %129
%138 = select i1 %136, i64 %132, i64 %131
br label %149
139: ; preds = %129
br i1 %136, label %149, label %140
140: ; preds = %139
%141 = add nsw i64 %132, -1
%142 = tail call %struct.syntree* @range_syntree(i64 %131, i64 %141)
%143 = load %struct.syntree*, %struct.syntree** %3
%144 = icmp eq %struct.syntree* %143, null
br i1 %144, label %147, label %145
145: ; preds = %140
%146 = tail call %struct.syntree* @alternation(%struct.syntree* %143, %struct.syntree* %142)
br label %147
147: ; preds = %140, %145
%148 = phi %struct.syntree* [ %146, %145 ], [ %142, %140 ]
store %struct.syntree* %148, %struct.syntree** %3
br label %149
149: ; preds = %137, %147, %139
%150 = phi i64 [ %131, %147 ], [ %131, %139 ], [ %138, %137 ]
%151 = phi i32 [ 0, %147 ], [ 0, %139 ], [ 1, %137 ]
%152 = add nuw nsw i64 %132, 1
%153 = icmp eq i64 %152, 129
br i1 %153, label %154, label %129
154: ; preds = %149
ret i64 %14
}