#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 int /*<<< orphan*/ FILE;

/* Variables and functions */
int EOF;
int getc(int /*<<< orphan*/ *);
int /*<<< orphan*/ *getfileparam(char *, int *);
int luaI_singlematch(int, char *, char **);
int /*<<< orphan*/ luaL_addchar(int);
int /*<<< orphan*/ luaL_buffer();
char *luaL_opt_lstr(int, int /*<<< orphan*/ *, int /*<<< orphan*/ *);
int /*<<< orphan*/ luaL_resetbuffer();
int /*<<< orphan*/ lua_error(char *);
int /*<<< orphan*/ lua_pushlstring(int /*<<< orphan*/, int);
int /*<<< orphan*/ read_until(int /*<<< orphan*/ *, int);
int /*<<< orphan*/ ungetc(int, int /*<<< orphan*/ *);
void io_read(void) {
  int arg = 3;
  FILE *f = getfileparam("_INPUT", &arg);
  char *p = (luaL_opt_lstr((arg), (NULL), NULL));
  luaL_resetbuffer();
  if (p == NULL)
    read_until(f, '\n');
  else if (p[0] == '.' && p[1] == '*' && p[2] == 0)
    read_until(f, EOF);
  else {
    int l = 0;
    int inskip = 0;
    int c = (EOF - 1);
    while (*p) {
      switch (*p) {
      case '{':
        inskip++;
        p++;
        continue;
      case '}':
        if (inskip == 0)
          lua_error("unbalanced braces in read pattern");
        inskip--;
        p++;
        continue;
      default: {
        char *ep;
        int m;
        if (c == (EOF - 1))
          c = getc(f);
        if (c == EOF) {
          luaI_singlematch(0, p, &ep);
          m = 0;
        } else {
          m = luaI_singlematch(c, p, &ep);
          if (m) {
            if (inskip == 0) {
              luaL_addchar(c);
              l++;
            }
            c = (EOF - 1);
          }
        }
        switch (*ep) {
        case '*':
          if (!m)
            p = ep + 1;
          continue;
        case '?':
          p = ep + 1;
          continue;
        default:
          if (m)
            p = ep;
          else
            goto break_while;
        }
      }
      }
    }
  break_while:
    if (c >= 0)
      ungetc(c, f);
    if (l > 0 || *p == 0)
      lua_pushlstring(luaL_buffer(), l);
  }
}


x86 assembly (clang, -O0):
<io_read>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
movl   $0x3,-0x4(%rbp)
lea    0xe3a(%rip),%rdi
lea    -0x4(%rbp),%rsi
call   1070 <getfileparam@plt>
mov    %rax,-0x10(%rbp)
mov    -0x4(%rbp),%edi
xor    %eax,%eax
mov    %eax,%edx
mov    %rdx,%rsi
call   1050 <luaL_opt_lstr@plt>
mov    %rax,-0x18(%rbp)
mov    $0x0,%al
call   10c0 <luaL_resetbuffer@plt>
cmpq   $0x0,-0x18(%rbp)
jne    120b <io_read+0x5b>
mov    -0x10(%rbp),%rdi
mov    $0xa,%esi
call   1090 <read_until@plt>
jmp    145d <io_read+0x2ad>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2e,%eax
jne    1254 <io_read+0xa4>
mov    -0x18(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x2a,%eax
jne    1254 <io_read+0xa4>
mov    -0x18(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x0,%eax
jne    1254 <io_read+0xa4>
mov    -0x10(%rbp),%rdi
mov    0x2da0(%rip),%rax
mov    (%rax),%esi
call   1090 <read_until@plt>
jmp    1458 <io_read+0x2a8>
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    0x2d7f(%rip),%rax
mov    (%rax),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%rax
cmpb   $0x0,(%rax)
je     140d <io_read+0x25d>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x38(%rbp)
sub    $0x7b,%eax
je     12a7 <io_read+0xf7>
jmp    1296 <io_read+0xe6>
mov    -0x38(%rbp),%eax
sub    $0x7d,%eax
je     12c1 <io_read+0x111>
jmp    12f1 <io_read+0x141>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1271 <io_read+0xc1>
cmpl   $0x0,-0x20(%rbp)
jne    12d7 <io_read+0x127>
lea    0xd35(%rip),%rdi
call   10b0 <lua_error@plt>
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1271 <io_read+0xc1>
mov    -0x24(%rbp),%eax
mov    0x2ced(%rip),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1314 <io_read+0x164>
mov    -0x10(%rbp),%rdi
call   10d0 <getc@plt>
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    0x2cca(%rip),%rcx
cmp    (%rcx),%eax
jne    1341 <io_read+0x191>
mov    -0x18(%rbp),%rsi
xor    %edi,%edi
lea    -0x30(%rbp),%rdx
call   1040 <luaI_singlematch@plt>
movl   $0x0,-0x34(%rbp)
jmp    138d <io_read+0x1dd>
mov    -0x24(%rbp),%edi
mov    -0x18(%rbp),%rsi
lea    -0x30(%rbp),%rdx
call   1040 <luaI_singlematch@plt>
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
je     1388 <io_read+0x1d8>
cmpl   $0x0,-0x20(%rbp)
jne    1379 <io_read+0x1c9>
mov    -0x24(%rbp),%edi
call   1060 <luaL_addchar@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    0x2c68(%rip),%rax
mov    (%rax),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    138d <io_read+0x1dd>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x3c(%rbp)
sub    $0x2a,%eax
je     13b6 <io_read+0x206>
jmp    13a5 <io_read+0x1f5>
mov    -0x3c(%rbp),%eax
sub    $0x3f,%eax
je     13d1 <io_read+0x221>
jmp    13e2 <io_read+0x232>
cmpl   $0x0,-0x34(%rbp)
jne    13cc <io_read+0x21c>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1271 <io_read+0xc1>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1271 <io_read+0xc1>
cmpl   $0x0,-0x34(%rbp)
je     13f9 <io_read+0x249>
mov    -0x30(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    13fe <io_read+0x24e>
jmp    1412 <io_read+0x262>
jmp    1403 <io_read+0x253>
jmp    1408 <io_read+0x258>
jmp    1271 <io_read+0xc1>
jmp    1412 <io_read+0x262>
cmpl   $0x0,-0x24(%rbp)
jl     1428 <io_read+0x278>
mov    -0x24(%rbp),%edi
mov    -0x10(%rbp),%rsi
call   1080 <ungetc@plt>
cmpl   $0x0,-0x1c(%rbp)
jg     1442 <io_read+0x292>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    1453 <io_read+0x2a3>
mov    $0x0,%al
call   1030 <luaL_buffer@plt>
mov    %eax,%edi
mov    -0x1c(%rbp),%esi
call   10a0 <lua_pushlstring@plt>
jmp    1458 <io_read+0x2a8>
jmp    145d <io_read+0x2ad>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<io_read>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
movl   $0x3,0x4(%rsp)
lea    0xe33(%rip),%rdi
lea    0x4(%rsp),%rsi
call   1070 <getfileparam@plt>
mov    %rax,%rbx
mov    0x4(%rsp),%edi
xor    %esi,%esi
xor    %edx,%edx
call   1050 <luaL_opt_lstr@plt>
mov    %rax,%r12
xor    %eax,%eax
call   10c0 <luaL_resetbuffer@plt>
test   %r12,%r12
je     1342 <io_read+0x192>
mov    (%r12),%al
cmp    $0x2e,%al
jne    1216 <io_read+0x66>
cmpb   $0x2a,0x1(%r12)
jne    1216 <io_read+0x66>
cmpb   $0x0,0x2(%r12)
je     139e <io_read+0x1ee>
mov    0x2dcb(%rip),%rcx
mov    (%rcx),%r14d
add    $0xffffffff,%r14d
test   %al,%al
mov    %rbx,0x8(%rsp)
je     135e <io_read+0x1ae>
xor    %r15d,%r15d
xor    %ebp,%ebp
mov    %ebp,%r13d
mov    %r12,%rbx
lea    0xdc4(%rip),%r12
jmp    126d <io_read+0xbd>
cs nopw 0x0(%rax,%rax,1)
nop
mov    $0x1,%ebp
cmp    $0x7b,%eax
jne    1289 <io_read+0xd9>
add    %ebp,%r15d
movzbl 0x1(%rbx),%eax
add    $0x1,%rbx
test   %al,%al
je     1351 <io_read+0x1a1>
movsbl %al,%eax
cmp    $0x7d,%eax
jne    1250 <io_read+0xa0>
mov    $0xffffffff,%ebp
test   %r15d,%r15d
jne    125a <io_read+0xaa>
mov    %r12,%rdi
call   10b0 <lua_error@plt>
jmp    125a <io_read+0xaa>
mov    0x2d58(%rip),%rbp
mov    0x0(%rbp),%r12d
lea    -0x1(%r12),%eax
cmp    %eax,%r14d
jne    12af <io_read+0xff>
mov    0x8(%rsp),%rdi
call   10d0 <getc@plt>
mov    %eax,%r14d
mov    0x0(%rbp),%r12d
cmp    %r12d,%r14d
mov    %r13d,%ebp
jne    12ce <io_read+0x11e>
xor    %r13d,%r13d
xor    %edi,%edi
mov    %rbx,%rsi
lea    0x10(%rsp),%rdx
call   1040 <luaI_singlematch@plt>
mov    %r12d,%r14d
jmp    1308 <io_read+0x158>
mov    %r14d,%edi
mov    %rbx,%rsi
lea    0x10(%rsp),%rdx
call   1040 <luaI_singlematch@plt>
test   %eax,%eax
je     1305 <io_read+0x155>
mov    %eax,%r13d
test   %r15d,%r15d
jne    12f5 <io_read+0x145>
mov    %r14d,%edi
call   1060 <luaL_addchar@plt>
add    $0x1,%ebp
mov    0x2cec(%rip),%rax
mov    (%rax),%r14d
add    $0xffffffff,%r14d
jmp    1308 <io_read+0x158>
xor    %r13d,%r13d
mov    0x10(%rsp),%r12
movsbl (%r12),%eax
cmp    $0x3f,%eax
je     1329 <io_read+0x179>
cmp    $0x2a,%eax
jne    132f <io_read+0x17f>
add    $0x1,%r12
test   %r13d,%r13d
cmovne %rbx,%r12
jmp    1334 <io_read+0x184>
add    $0x1,%r12
jmp    1334 <io_read+0x184>
test   %r13d,%r13d
je     13ac <io_read+0x1fc>
mov    (%r12),%al
test   %al,%al
jne    1236 <io_read+0x86>
jmp    1360 <io_read+0x1b0>
mov    %rbx,%rdi
mov    $0xa,%esi
call   1090 <read_until@plt>
jmp    138f <io_read+0x1df>
mov    %rbx,%r12
mov    %r13d,%ebp
test   %r14d,%r14d
jns    1365 <io_read+0x1b5>
jmp    1372 <io_read+0x1c2>
xor    %ebp,%ebp
test   %r14d,%r14d
js     1372 <io_read+0x1c2>
mov    %r14d,%edi
mov    0x8(%rsp),%rsi
call   1080 <ungetc@plt>
test   %ebp,%ebp
jle    1388 <io_read+0x1d8>
xor    %eax,%eax
call   1030 <luaL_buffer@plt>
mov    %eax,%edi
mov    %ebp,%esi
call   10a0 <lua_pushlstring@plt>
jmp    138f <io_read+0x1df>
cmpb   $0x0,(%r12)
je     1376 <io_read+0x1c6>
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x2c43(%rip),%rax
mov    (%rax),%esi
mov    %rbx,%rdi
jmp    134a <io_read+0x19a>
mov    %rbx,%r12
test   %r14d,%r14d
jns    1365 <io_read+0x1b5>
jmp    1372 <io_read+0x1c2>

LLVM IR (-O0):
@.str = [7 x i8] c"_INPUT\00"
@EOF = global i32 0
@.str.1 = [34 x i8] c"unbalanced braces in read pattern\00"
define void @io_read() {
%1 = alloca i32
%2 = alloca i32*
%3 = alloca i8*
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i32
store i32 3, i32* %1
%9 = call i32* @getfileparam(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0), i32* %1)
store i32* %9, i32** %2
%10 = load i32, i32* %1
%11 = call i8* @luaL_opt_lstr(i32 %10, i32* null, i32* null)
store i8* %11, i8** %3
%12 = call i32 (...) @luaL_resetbuffer()
%13 = load i8*, i8** %3
%14 = icmp eq i8* %13, null
br i1 %14, label %15, label %18
15: ; preds = %0
%16 = load i32*, i32** %2
%17 = call i32 @read_until(i32* %16, i32 10)
br label %144
18: ; preds = %0
%19 = load i8*, i8** %3
%20 = getelementptr inbounds i8, i8* %19, i64 0
%21 = load i8, i8* %20
%22 = sext i8 %21 to i32
%23 = icmp eq i32 %22, 46
br i1 %23, label %24, label %40
24: ; preds = %18
%25 = load i8*, i8** %3
%26 = getelementptr inbounds i8, i8* %25, i64 1
%27 = load i8, i8* %26
%28 = sext i8 %27 to i32
%29 = icmp eq i32 %28, 42
br i1 %29, label %30, label %40
30: ; preds = %24
%31 = load i8*, i8** %3
%32 = getelementptr inbounds i8, i8* %31, i64 2
%33 = load i8, i8* %32
%34 = sext i8 %33 to i32
%35 = icmp eq i32 %34, 0
br i1 %35, label %36, label %40
36: ; preds = %30
%37 = load i32*, i32** %2
%38 = load i32, i32* @EOF
%39 = call i32 @read_until(i32* %37, i32 %38)
br label %143
40: ; preds = %30, %24, %18
store i32 0, i32* %4
store i32 0, i32* %5
%41 = load i32, i32* @EOF
%42 = sub nsw i32 %41, 1
store i32 %42, i32* %6
br label %43
43: ; preds = %121, %110, %109, %61, %51, %40
%44 = load i8*, i8** %3
%45 = load i8, i8* %44
%46 = icmp ne i8 %45, 0
br i1 %46, label %47, label %122
47: ; preds = %43
%48 = load i8*, i8** %3
%49 = load i8, i8* %48
%50 = sext i8 %49 to i32
switch i32 %50, label %66 [
i32 123, label %51
i32 125, label %56
]
51: ; preds = %47
%52 = load i32, i32* %5
%53 = add nsw i32 %52, 1
store i32 %53, i32* %5
%54 = load i8*, i8** %3
%55 = getelementptr inbounds i8, i8* %54, i32 1
store i8* %55, i8** %3
br label %43
56: ; preds = %47
%57 = load i32, i32* %5
%58 = icmp eq i32 %57, 0
br i1 %58, label %59, label %61
59: ; preds = %56
%60 = call i32 @lua_error(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.1, i64 0, i64 0))
br label %61
61: ; preds = %59, %56
%62 = load i32, i32* %5
%63 = add nsw i32 %62, -1
store i32 %63, i32* %5
%64 = load i8*, i8** %3
%65 = getelementptr inbounds i8, i8* %64, i32 1
store i8* %65, i8** %3
br label %43
66: ; preds = %47
%67 = load i32, i32* %6
%68 = load i32, i32* @EOF
%69 = sub nsw i32 %68, 1
%70 = icmp eq i32 %67, %69
br i1 %70, label %71, label %74
71: ; preds = %66
%72 = load i32*, i32** %2
%73 = call i32 @getc(i32* %72)
store i32 %73, i32* %6
br label %74
74: ; preds = %71, %66
%75 = load i32, i32* %6
%76 = load i32, i32* @EOF
%77 = icmp eq i32 %75, %76
br i1 %77, label %78, label %81
78: ; preds = %74
%79 = load i8*, i8** %3
%80 = call i32 @luaI_singlematch(i32 0, i8* %79, i8** %7)
store i32 0, i32* %8
br label %99
81: ; preds = %74
%82 = load i32, i32* %6
%83 = load i8*, i8** %3
%84 = call i32 @luaI_singlematch(i32 %82, i8* %83, i8** %7)
store i32 %84, i32* %8
%85 = load i32, i32* %8
%86 = icmp ne i32 %85, 0
br i1 %86, label %87, label %98
87: ; preds = %81
%88 = load i32, i32* %5
%89 = icmp eq i32 %88, 0
br i1 %89, label %90, label %95
90: ; preds = %87
%91 = load i32, i32* %6
%92 = call i32 @luaL_addchar(i32 %91)
%93 = load i32, i32* %4
%94 = add nsw i32 %93, 1
store i32 %94, i32* %4
br label %95
95: ; preds = %90, %87
%96 = load i32, i32* @EOF
%97 = sub nsw i32 %96, 1
store i32 %97, i32* %6
br label %98
98: ; preds = %95, %81
br label %99
99: ; preds = %98, %78
%100 = load i8*, i8** %7
%101 = load i8, i8* %100
%102 = sext i8 %101 to i32
switch i32 %102, label %113 [
i32 42, label %103
i32 63, label %110
]
103: ; preds = %99
%104 = load i32, i32* %8
%105 = icmp ne i32 %104, 0
br i1 %105, label %109, label %106
106: ; preds = %103
%107 = load i8*, i8** %7
%108 = getelementptr inbounds i8, i8* %107, i64 1
store i8* %108, i8** %3
br label %109
109: ; preds = %106, %103
br label %43
110: ; preds = %99
%111 = load i8*, i8** %7
%112 = getelementptr inbounds i8, i8* %111, i64 1
store i8* %112, i8** %3
br label %43
113: ; preds = %99
%114 = load i32, i32* %8
%115 = icmp ne i32 %114, 0
br i1 %115, label %116, label %118
116: ; preds = %113
%117 = load i8*, i8** %7
store i8* %117, i8** %3
br label %119
118: ; preds = %113
br label %123
119: ; preds = %116
br label %120
120: ; preds = %119
br label %121
121: ; preds = %120
br label %43
122: ; preds = %43
br label %123
123: ; preds = %122, %118
%124 = load i32, i32* %6
%125 = icmp sge i32 %124, 0
br i1 %125, label %126, label %130
126: ; preds = %123
%127 = load i32, i32* %6
%128 = load i32*, i32** %2
%129 = call i32 @ungetc(i32 %127, i32* %128)
br label %130
130: ; preds = %126, %123
%131 = load i32, i32* %4
%132 = icmp sgt i32 %131, 0
br i1 %132, label %138, label %133
133: ; preds = %130
%134 = load i8*, i8** %3
%135 = load i8, i8* %134
%136 = sext i8 %135 to i32
%137 = icmp eq i32 %136, 0
br i1 %137, label %138, label %142
138: ; preds = %133, %130
%139 = call i32 (...) @luaL_buffer()
%140 = load i32, i32* %4
%141 = call i32 @lua_pushlstring(i32 %139, i32 %140)
br label %142
142: ; preds = %138, %133
br label %143
143: ; preds = %142, %36
br label %144
144: ; preds = %143, %15
ret void
}

LLVM IR (-O2):
@.str = [7 x i8] c"_INPUT\00"
@EOF = global i32 0
@.str.1 = [34 x i8] c"unbalanced braces in read pattern\00"
define void @io_read() {
%1 = alloca i32
%2 = alloca i8*
%3 = bitcast i32* %1 to i8*
store i32 3, i32* %1
%4 = call i32* @getfileparam(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0), i32* %1)
%5 = load i32, i32* %1
%6 = call i8* @luaL_opt_lstr(i32 %5, i32* null, i32* null)
%7 = call i32 (...) @luaL_resetbuffer()
%8 = icmp eq i8* %6, null
br i1 %8, label %9, label %11
9: ; preds = %0
%10 = call i32 @read_until(i32* %4, i32 10)
br label %111
11: ; preds = %0
%12 = load i8, i8* %6
%13 = icmp eq i8 %12, 46
br i1 %13, label %14, label %25
14: ; preds = %11
%15 = getelementptr inbounds i8, i8* %6, i64 1
%16 = load i8, i8* %15
%17 = icmp eq i8 %16, 42
br i1 %17, label %18, label %25
18: ; preds = %14
%19 = getelementptr inbounds i8, i8* %6, i64 2
%20 = load i8, i8* %19
%21 = icmp eq i8 %20, 0
br i1 %21, label %22, label %25
22: ; preds = %18
%23 = load i32, i32* @EOF
%24 = call i32 @read_until(i32* %4, i32 %23)
br label %111
25: ; preds = %18, %14, %11
%26 = load i32, i32* @EOF
%27 = add nsw i32 %26, -1
%28 = bitcast i8** %2 to i8*
%29 = icmp eq i8 %12, 0
br i1 %29, label %96, label %30
30: ; preds = %25, %92
%31 = phi i32 [ %78, %92 ], [ %27, %25 ]
%32 = phi i32 [ %38, %92 ], [ 0, %25 ]
%33 = phi i32 [ %77, %92 ], [ 0, %25 ]
%34 = phi i8* [ %93, %92 ], [ %6, %25 ]
%35 = phi i8 [ %94, %92 ], [ %12, %25 ]
br label %36
36: ; preds = %30, %41
%37 = phi i8 [ %45, %41 ], [ %35, %30 ]
%38 = phi i32 [ %43, %41 ], [ %32, %30 ]
%39 = phi i8* [ %44, %41 ], [ %34, %30 ]
%40 = sext i8 %37 to i32
switch i32 %40, label %51 [
i32 123, label %41
i32 125, label %47
]
41: ; preds = %36, %47, %49
%42 = phi i32 [ -1, %49 ], [ -1, %47 ], [ 1, %36 ]
%43 = add nsw i32 %38, %42
%44 = getelementptr inbounds i8, i8* %39, i64 1
%45 = load i8, i8* %44
%46 = icmp eq i8 %45, 0
br i1 %46, label %96, label %36
47: ; preds = %36
%48 = icmp eq i32 %38, 0
br i1 %48, label %49, label %41
49: ; preds = %47
%50 = call i32 @lua_error(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.1, i64 0, i64 0))
br label %41
51: ; preds = %36
%52 = load i32, i32* @EOF
%53 = add nsw i32 %52, -1
%54 = icmp eq i32 %31, %53
br i1 %54, label %55, label %58
55: ; preds = %51
%56 = call i32 @getc(i32* %4)
%57 = load i32, i32* @EOF
br label %58
58: ; preds = %55, %51
%59 = phi i32 [ %57, %55 ], [ %52, %51 ]
%60 = phi i32 [ %56, %55 ], [ %31, %51 ]
%61 = icmp eq i32 %60, %59
br i1 %61, label %62, label %64
62: ; preds = %58
%63 = call i32 @luaI_singlematch(i32 0, i8* %39, i8** %2)
br label %76
64: ; preds = %58
%65 = call i32 @luaI_singlematch(i32 %60, i8* %39, i8** %2)
%66 = icmp eq i32 %65, 0
br i1 %66, label %76, label %67
67: ; preds = %64
%68 = icmp eq i32 %38, 0
br i1 %68, label %69, label %72
69: ; preds = %67
%70 = call i32 @luaL_addchar(i32 %60)
%71 = add nsw i32 %33, 1
br label %72
72: ; preds = %69, %67
%73 = phi i32 [ %71, %69 ], [ %33, %67 ]
%74 = load i32, i32* @EOF
%75 = add nsw i32 %74, -1
br label %76
76: ; preds = %64, %72, %62
%77 = phi i32 [ %33, %62 ], [ %73, %72 ], [ %33, %64 ]
%78 = phi i32 [ %59, %62 ], [ %75, %72 ], [ %60, %64 ]
%79 = phi i32 [ 0, %62 ], [ %65, %72 ], [ 0, %64 ]
%80 = load i8*, i8** %2
%81 = load i8, i8* %80
%82 = sext i8 %81 to i32
switch i32 %82, label %89 [
i32 42, label %83
i32 63, label %87
]
83: ; preds = %76
%84 = icmp eq i32 %79, 0
%85 = getelementptr inbounds i8, i8* %80, i64 1
%86 = select i1 %84, i8* %85, i8* %39
br label %92
87: ; preds = %76
%88 = getelementptr inbounds i8, i8* %80, i64 1
br label %92
89: ; preds = %76
%90 = icmp eq i32 %79, 0
br i1 %90, label %91, label %92
91: ; preds = %89
br label %96
92: ; preds = %87, %83, %89
%93 = phi i8* [ %80, %89 ], [ %86, %83 ], [ %88, %87 ]
%94 = load i8, i8* %93
%95 = icmp eq i8 %94, 0
br i1 %95, label %96, label %30
96: ; preds = %92, %41, %25, %91
%97 = phi i8* [ %39, %91 ], [ %6, %25 ], [ %44, %41 ], [ %93, %92 ]
%98 = phi i32 [ %77, %91 ], [ 0, %25 ], [ %33, %41 ], [ %77, %92 ]
%99 = phi i32 [ %78, %91 ], [ %27, %25 ], [ %31, %41 ], [ %78, %92 ]
%100 = icmp sgt i32 %99, -1
br i1 %100, label %101, label %103
101: ; preds = %96
%102 = call i32 @ungetc(i32 %99, i32* %4)
br label %103
103: ; preds = %101, %96
%104 = icmp sgt i32 %98, 0
br i1 %104, label %108, label %105
105: ; preds = %103
%106 = load i8, i8* %97
%107 = icmp eq i8 %106, 0
br i1 %107, label %108, label %111
108: ; preds = %105, %103
%109 = call i32 (...) @luaL_buffer()
%110 = call i32 @lua_pushlstring(i32 %109, i32 %98)
br label %111
111: ; preds = %105, %108, %22, %9
ret void
}