void mylex(char *input_line, char tokens[100][200], int *num) {
  int i = 0, j = 0, k = 0;
  char ch = input_line[i++];
  while (ch != 0) {
    if (ch == '\n' || ch == '\r' || ch == ' ' || ch == ',' || ch == ';' ||
        ch == '(' || ch == ')' || ch == '{' || ch == '}') {
      if (j != 0) {
        tokens[k][j] = '\0';
        j = 0;
        k++;
      }
      if (!(ch == '\n' || ch == '\r' || ch == ' ')) {
        tokens[k][0] = ch;
        tokens[k][1] = 0;
        k++;
      }
    } else
      tokens[k][j++] = ch;
    ch = input_line[i++];
  }
  tokens[k][j] = 0;
  *num = k - 1;
}


x86 assembly (clang, -O0):
<mylex>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x1c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x25(%rbp)
movsbl -0x25(%rbp),%eax
cmp    $0x0,%eax
je     1298 <mylex+0x198>
movsbl -0x25(%rbp),%eax
cmp    $0xa,%eax
je     11bf <mylex+0xbf>
movsbl -0x25(%rbp),%eax
cmp    $0xd,%eax
je     11bf <mylex+0xbf>
movsbl -0x25(%rbp),%eax
cmp    $0x20,%eax
je     11bf <mylex+0xbf>
movsbl -0x25(%rbp),%eax
cmp    $0x2c,%eax
je     11bf <mylex+0xbf>
movsbl -0x25(%rbp),%eax
cmp    $0x3b,%eax
je     11bf <mylex+0xbf>
movsbl -0x25(%rbp),%eax
cmp    $0x28,%eax
je     11bf <mylex+0xbf>
movsbl -0x25(%rbp),%eax
cmp    $0x29,%eax
je     11bf <mylex+0xbf>
movsbl -0x25(%rbp),%eax
cmp    $0x7b,%eax
je     11bf <mylex+0xbf>
movsbl -0x25(%rbp),%eax
cmp    $0x7d,%eax
jne    1255 <mylex+0x155>
cmpl   $0x0,-0x20(%rbp)
je     11f3 <mylex+0xf3>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
movl   $0x0,-0x20(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
movsbl -0x25(%rbp),%eax
cmp    $0xa,%eax
je     1250 <mylex+0x150>
movsbl -0x25(%rbp),%eax
cmp    $0xd,%eax
je     1250 <mylex+0x150>
movsbl -0x25(%rbp),%eax
cmp    $0x20,%eax
je     1250 <mylex+0x150>
mov    -0x25(%rbp),%cl
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rdx
imul   $0xc8,%rdx,%rdx
add    %rdx,%rax
mov    %cl,(%rax)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movb   $0x0,0x1(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    127b <mylex+0x17b>
mov    -0x25(%rbp),%dl
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x1c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x25(%rbp)
jmp    113d <mylex+0x3d>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<mylex>:
push   %rbx
xor    %r10d,%r10d
movabs $0x100002400,%r9
movabs $0x800130100002400,%r8
xor    %r11d,%r11d
jmp    113a <mylex+0x3a>
nopl   (%rax)
movslq %r11d,%r11
imul   $0xc8,%r11,%rax
mov    %cl,(%rsi,%rax,1)
movb   $0x0,0x1(%rsi,%rax,1)
add    $0x1,%r11d
add    $0x1,%rdi
movzbl (%rdi),%ecx
cmp    $0x3b,%rcx
ja     1190 <mylex+0x90>
bt     %rcx,%r8
jae    117e <mylex+0x7e>
test   %r10d,%r10d
je     1167 <mylex+0x67>
movslq %r11d,%r11
movslq %r10d,%r10
imul   $0xc8,%r11,%rax
add    %rsi,%rax
movb   $0x0,(%r10,%rax,1)
add    $0x1,%r11d
xor    %r10d,%r10d
cmp    $0x20,%cl
ja     1120 <mylex+0x20>
movzbl %cl,%eax
bt     %rax,%r9
jae    1120 <mylex+0x20>
add    $0x1,%rdi
jmp    113a <mylex+0x3a>
test   %rcx,%rcx
je     11b3 <mylex+0xb3>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    $0x7d,%cl
je     1149 <mylex+0x49>
cmp    $0x7b,%cl
je     1149 <mylex+0x49>
movslq %r11d,%rax
movslq %r10d,%rbx
add    $0x1,%r10d
imul   $0xc8,%rax,%rax
add    %rsi,%rax
mov    %cl,(%rbx,%rax,1)
jmp    1178 <mylex+0x78>
movslq %r11d,%rax
movslq %r10d,%rcx
imul   $0xc8,%rax,%rax
add    %rax,%rsi
movb   $0x0,(%rcx,%rsi,1)
add    $0xffffffff,%r11d
mov    %r11d,(%rdx)
pop    %rbx
ret

LLVM IR (-O0):
define void @mylex(i8* %0, [200 x i8]* %1, i32* %2) {
%4 = alloca i8*
%5 = alloca [200 x i8]*
%6 = alloca i32*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i8
store i8* %0, i8** %4
store [200 x i8]* %1, [200 x i8]** %5
store i32* %2, i32** %6
store i32 0, i32* %7
store i32 0, i32* %8
store i32 0, i32* %9
%11 = load i8*, i8** %4
%12 = load i32, i32* %7
%13 = add nsw i32 %12, 1
store i32 %13, i32* %7
%14 = sext i32 %12 to i64
%15 = getelementptr inbounds i8, i8* %11, i64 %14
%16 = load i8, i8* %15
store i8 %16, i8* %10
br label %17
17: ; preds = %107, %3
%18 = load i8, i8* %10
%19 = sext i8 %18 to i32
%20 = icmp ne i32 %19, 0
br i1 %20, label %21, label %114
21: ; preds = %17
%22 = load i8, i8* %10
%23 = sext i8 %22 to i32
%24 = icmp eq i32 %23, 10
br i1 %24, label %57, label %25
25: ; preds = %21
%26 = load i8, i8* %10
%27 = sext i8 %26 to i32
%28 = icmp eq i32 %27, 13
br i1 %28, label %57, label %29
29: ; preds = %25
%30 = load i8, i8* %10
%31 = sext i8 %30 to i32
%32 = icmp eq i32 %31, 32
br i1 %32, label %57, label %33
33: ; preds = %29
%34 = load i8, i8* %10
%35 = sext i8 %34 to i32
%36 = icmp eq i32 %35, 44
br i1 %36, label %57, label %37
37: ; preds = %33
%38 = load i8, i8* %10
%39 = sext i8 %38 to i32
%40 = icmp eq i32 %39, 59
br i1 %40, label %57, label %41
41: ; preds = %37
%42 = load i8, i8* %10
%43 = sext i8 %42 to i32
%44 = icmp eq i32 %43, 40
br i1 %44, label %57, label %45
45: ; preds = %41
%46 = load i8, i8* %10
%47 = sext i8 %46 to i32
%48 = icmp eq i32 %47, 41
br i1 %48, label %57, label %49
49: ; preds = %45
%50 = load i8, i8* %10
%51 = sext i8 %50 to i32
%52 = icmp eq i32 %51, 123
br i1 %52, label %57, label %53
53: ; preds = %49
%54 = load i8, i8* %10
%55 = sext i8 %54 to i32
%56 = icmp eq i32 %55, 125
br i1 %56, label %57, label %97
57: ; preds = %53, %49, %45, %41, %37, %33, %29, %25, %21
%58 = load i32, i32* %8
%59 = icmp ne i32 %58, 0
br i1 %59, label %60, label %70
60: ; preds = %57
%61 = load [200 x i8]*, [200 x i8]** %5
%62 = load i32, i32* %9
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds [200 x i8], [200 x i8]* %61, i64 %63
%65 = load i32, i32* %8
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds [200 x i8], [200 x i8]* %64, i64 0, i64 %66
store i8 0, i8* %67
store i32 0, i32* %8
%68 = load i32, i32* %9
%69 = add nsw i32 %68, 1
store i32 %69, i32* %9
br label %70
70: ; preds = %60, %57
%71 = load i8, i8* %10
%72 = sext i8 %71 to i32
%73 = icmp eq i32 %72, 10
br i1 %73, label %96, label %74
74: ; preds = %70
%75 = load i8, i8* %10
%76 = sext i8 %75 to i32
%77 = icmp eq i32 %76, 13
br i1 %77, label %96, label %78
78: ; preds = %74
%79 = load i8, i8* %10
%80 = sext i8 %79 to i32
%81 = icmp eq i32 %80, 32
br i1 %81, label %96, label %82
82: ; preds = %78
%83 = load i8, i8* %10
%84 = load [200 x i8]*, [200 x i8]** %5
%85 = load i32, i32* %9
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds [200 x i8], [200 x i8]* %84, i64 %86
%88 = getelementptr inbounds [200 x i8], [200 x i8]* %87, i64 0, i64 0
store i8 %83, i8* %88
%89 = load [200 x i8]*, [200 x i8]** %5
%90 = load i32, i32* %9
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds [200 x i8], [200 x i8]* %89, i64 %91
%93 = getelementptr inbounds [200 x i8], [200 x i8]* %92, i64 0, i64 1
store i8 0, i8* %93
%94 = load i32, i32* %9
%95 = add nsw i32 %94, 1
store i32 %95, i32* %9
br label %96
96: ; preds = %82, %78, %74, %70
br label %107
97: ; preds = %53
%98 = load i8, i8* %10
%99 = load [200 x i8]*, [200 x i8]** %5
%100 = load i32, i32* %9
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds [200 x i8], [200 x i8]* %99, i64 %101
%103 = load i32, i32* %8
%104 = add nsw i32 %103, 1
store i32 %104, i32* %8
%105 = sext i32 %103 to i64
%106 = getelementptr inbounds [200 x i8], [200 x i8]* %102, i64 0, i64 %105
store i8 %98, i8* %106
br label %107
107: ; preds = %97, %96
%108 = load i8*, i8** %4
%109 = load i32, i32* %7
%110 = add nsw i32 %109, 1
store i32 %110, i32* %7
%111 = sext i32 %109 to i64
%112 = getelementptr inbounds i8, i8* %108, i64 %111
%113 = load i8, i8* %112
store i8 %113, i8* %10
br label %17
114: ; preds = %17
%115 = load [200 x i8]*, [200 x i8]** %5
%116 = load i32, i32* %9
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds [200 x i8], [200 x i8]* %115, i64 %117
%119 = load i32, i32* %8
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds [200 x i8], [200 x i8]* %118, i64 0, i64 %120
store i8 0, i8* %121
%122 = load i32, i32* %9
%123 = sub nsw i32 %122, 1
%124 = load i32*, i32** %6
store i32 %123, i32* %124
ret void
}

LLVM IR (-O2):
define void @mylex(i8* nocapture %0, [200 x i8]* nocapture writeonly %1, i32* nocapture writeonly %2) {
br label %4
4: ; preds = %29, %3
%5 = phi i64 [ %32, %29 ], [ 1, %3 ]
%6 = phi i32 [ %30, %29 ], [ 0, %3 ]
%7 = phi i32 [ %31, %29 ], [ 0, %3 ]
%8 = phi i8* [ %33, %29 ], [ %0, %3 ]
%9 = load i8, i8* %8
switch i8 %9, label %24 [
i8 0, label %34
i8 125, label %10
i8 123, label %10
i8 59, label %10
i8 44, label %10
i8 41, label %10
i8 40, label %10
i8 32, label %10
i8 13, label %10
i8 10, label %10
]
10: ; preds = %4, %4, %4, %4, %4, %4, %4, %4, %4
%11 = icmp eq i32 %6, 0
br i1 %11, label %17, label %12
12: ; preds = %10
%13 = sext i32 %7 to i64
%14 = sext i32 %6 to i64
%15 = getelementptr inbounds [200 x i8], [200 x i8]* %1, i64 %13, i64 %14
store i8 0, i8* %15
%16 = add nsw i32 %7, 1
br label %17
17: ; preds = %12, %10
%18 = phi i32 [ %16, %12 ], [ %7, %10 ]
switch i8 %9, label %19 [
i8 32, label %29
i8 13, label %29
i8 10, label %29
]
19: ; preds = %17
%20 = sext i32 %18 to i64
%21 = getelementptr inbounds [200 x i8], [200 x i8]* %1, i64 %20, i64 0
store i8 %9, i8* %21
%22 = getelementptr inbounds [200 x i8], [200 x i8]* %1, i64 %20, i64 1
store i8 0, i8* %22
%23 = add nsw i32 %18, 1
br label %29
24: ; preds = %4
%25 = sext i32 %7 to i64
%26 = add nsw i32 %6, 1
%27 = sext i32 %6 to i64
%28 = getelementptr inbounds [200 x i8], [200 x i8]* %1, i64 %25, i64 %27
store i8 %9, i8* %28
br label %29
29: ; preds = %17, %17, %17, %19, %24
%30 = phi i32 [ 0, %17 ], [ 0, %19 ], [ %26, %24 ], [ 0, %17 ], [ 0, %17 ]
%31 = phi i32 [ %18, %17 ], [ %23, %19 ], [ %7, %24 ], [ %18, %17 ], [ %18, %17 ]
%32 = add nuw i64 %5, 1
%33 = getelementptr inbounds i8, i8* %0, i64 %5
br label %4
34: ; preds = %4
%35 = sext i32 %7 to i64
%36 = sext i32 %6 to i64
%37 = getelementptr inbounds [200 x i8], [200 x i8]* %1, i64 %35, i64 %36
store i8 0, i8* %37
%38 = add nsw i32 %7, -1
store i32 %38, i32* %2
ret void
}