#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 atoi(char *);
int /*<<< orphan*/ free(char *);
scalar_t__ malloc(int);
int strlen(char *);
int get_token_name(char *lexeme) {
  if (lexeme == NULL) {
    return -1;
  }
  int start = 1;
  int end = 0;
  int i = 0;
  while (end < strlen(lexeme)) {
    if (lexeme[end] == ',') {
      break;
    }
    end++;
  }
  char *tmp = (char *)malloc(sizeof(char) * (end - start) + 1);
  int j;
  for (j = 0; j < (end - start + 1); j++) {
    tmp[j] = lexeme[start + j];
  }
  tmp[(end - start)] = '\0';
  int x = atoi(tmp);
  free(tmp);
  return x;
}


x86 assembly (clang, -O0):
<get_token_name>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    1163 <get_token_name+0x23>
movl   $0xffffffff,-0x4(%rbp)
jmp    1247 <get_token_name+0x107>
movl   $0x1,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,%ecx
mov    -0x34(%rbp),%eax
cmp    %ecx,%eax
jge    11bc <get_token_name+0x7c>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2c,%eax
jne    11ae <get_token_name+0x6e>
jmp    11bc <get_token_name+0x7c>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1178 <get_token_name+0x38>
mov    -0x18(%rbp),%eax
sub    -0x14(%rbp),%eax
cltq
shl    $0x0,%rax
add    $0x1,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    121b <get_token_name+0xdb>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11de <get_token_name+0x9e>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x28(%rbp),%rdi
call   1060 <atoi@plt>
mov    %eax,-0x30(%rbp)
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_token_name>:
test   %rdi,%rdi
je     11ff <get_token_name+0xbf>
push   %r15
push   %r14
push   %rbx
mov    %rdi,%r15
call   1040 <strlen@plt>
xor    %ebx,%ebx
test   %eax,%eax
jle    117a <get_token_name+0x3a>
nopl   0x0(%rax)
cmpb   $0x2c,(%r15,%rbx,1)
je     117a <get_token_name+0x3a>
add    $0x1,%rbx
mov    %r15,%rdi
call   1040 <strlen@plt>
cltq
cmp    %rax,%rbx
jl     1160 <get_token_name+0x20>
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%r14
mov    %ebx,%eax
sub    $0x1,%eax
movslq %eax,%r8
jb     1247 <get_token_name+0x107>
mov    %ebx,%eax
cmp    $0x8,%ebx
jb     11bd <get_token_name+0x7d>
lea    (%rax,%r15,1),%rcx
add    $0x1,%rcx
cmp    %r14,%rcx
jbe    1266 <get_token_name+0x126>
mov    %r14,%rcx
add    %rax,%rcx
lea    0x1(%r15),%rdx
cmp    %rcx,%rdx
jae    1266 <get_token_name+0x126>
xor    %edx,%edx
mov    %rdx,%rdi
not    %rdi
add    %rax,%rdi
mov    %rax,%rcx
and    $0x3,%rcx
je     1205 <get_token_name+0xc5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x1(%rdx),%rsi
movzbl 0x1(%r15,%rdx,1),%ebx
mov    %bl,(%r14,%rdx,1)
mov    %rsi,%rdx
add    $0xffffffffffffffff,%rcx
jne    11e0 <get_token_name+0xa0>
cmp    $0x3,%rdi
jb     1247 <get_token_name+0x107>
jmp    1210 <get_token_name+0xd0>
mov    $0xffffffff,%eax
ret
mov    %rdx,%rsi
cmp    $0x3,%rdi
jb     1247 <get_token_name+0x107>
xchg   %ax,%ax
movzbl 0x1(%r15,%rsi,1),%ecx
mov    %cl,(%r14,%rsi,1)
movzbl 0x2(%r15,%rsi,1),%ecx
mov    %cl,0x1(%r14,%rsi,1)
movzbl 0x3(%r15,%rsi,1),%ecx
mov    %cl,0x2(%r14,%rsi,1)
movzbl 0x4(%r15,%rsi,1),%ecx
mov    %cl,0x3(%r14,%rsi,1)
lea    0x4(%rsi),%rcx
mov    %rcx,%rsi
cmp    %rcx,%rax
jne    1210 <get_token_name+0xd0>
movb   $0x0,(%r14,%r8,1)
mov    %r14,%rdi
call   1060 <atoi@plt>
mov    %eax,%ebx
mov    %r14,%rdi
call   1030 <free@plt>
mov    %ebx,%eax
pop    %rbx
pop    %r14
pop    %r15
ret
cmp    $0x20,%ebx
jae    1272 <get_token_name+0x132>
xor    %edx,%edx
jmp    1348 <get_token_name+0x208>
mov    %eax,%edx
and    $0xffffffe0,%edx
lea    -0x20(%rdx),%rcx
mov    %rcx,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %esi,%ebx
and    $0x3,%ebx
cmp    $0x60,%rcx
jae    1295 <get_token_name+0x155>
xor    %edi,%edi
jmp    1309 <get_token_name+0x1c9>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups 0x1(%r15,%rdi,1),%xmm0
movups 0x11(%r15,%rdi,1),%xmm1
movups %xmm0,(%r14,%rdi,1)
movups %xmm1,0x10(%r14,%rdi,1)
movups 0x21(%r15,%rdi,1),%xmm0
movups 0x31(%r15,%rdi,1),%xmm1
movups %xmm0,0x20(%r14,%rdi,1)
movups %xmm1,0x30(%r14,%rdi,1)
movups 0x41(%r15,%rdi,1),%xmm0
movups 0x51(%r15,%rdi,1),%xmm1
movups %xmm0,0x40(%r14,%rdi,1)
movups %xmm1,0x50(%r14,%rdi,1)
movups 0x61(%r15,%rdi,1),%xmm0
movups 0x71(%r15,%rdi,1),%xmm1
movups %xmm0,0x60(%r14,%rdi,1)
movups %xmm1,0x70(%r14,%rdi,1)
sub    $0xffffffffffffff80,%rdi
add    $0xfffffffffffffffc,%rsi
jne    12a0 <get_token_name+0x160>
test   %rbx,%rbx
je     1337 <get_token_name+0x1f7>
xchg   %ax,%ax
mov    %rdi,%rcx
or     $0x1,%rcx
movups (%r15,%rcx,1),%xmm0
movups 0x10(%r15,%rcx,1),%xmm1
movups %xmm0,(%r14,%rdi,1)
movups %xmm1,0x10(%r14,%rdi,1)
add    $0x20,%rdi
add    $0xffffffffffffffff,%rbx
jne    1310 <get_token_name+0x1d0>
cmp    %rax,%rdx
je     1247 <get_token_name+0x107>
test   $0x18,%al
je     11bf <get_token_name+0x7f>
mov    %rdx,%rcx
mov    %eax,%edx
and    $0xfffffff8,%edx
mov    0x1(%r15,%rcx,1),%rsi
mov    %rsi,(%r14,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rdx
jne    1350 <get_token_name+0x210>
cmp    %rax,%rdx
je     1247 <get_token_name+0x107>
jmp    11bf <get_token_name+0x7f>

LLVM IR (-O0):
define i32 @get_token_name(i8* %0) {
%2 = alloca i32
%3 = alloca i8*
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i32
store i8* %0, i8** %3
%10 = load i8*, i8** %3
%11 = icmp eq i8* %10, null
br i1 %11, label %12, label %13
12: ; preds = %1
store i32 -1, i32* %2
br label %75
13: ; preds = %1
store i32 1, i32* %4
store i32 0, i32* %5
store i32 0, i32* %6
br label %14
14: ; preds = %28, %13
%15 = load i32, i32* %5
%16 = load i8*, i8** %3
%17 = call i32 @strlen(i8* %16)
%18 = icmp slt i32 %15, %17
br i1 %18, label %19, label %31
19: ; preds = %14
%20 = load i8*, i8** %3
%21 = load i32, i32* %5
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds i8, i8* %20, i64 %22
%24 = load i8, i8* %23
%25 = sext i8 %24 to i32
%26 = icmp eq i32 %25, 44
br i1 %26, label %27, label %28
27: ; preds = %19
br label %31
28: ; preds = %19
%29 = load i32, i32* %5
%30 = add nsw i32 %29, 1
store i32 %30, i32* %5
br label %14
31: ; preds = %27, %14
%32 = load i32, i32* %5
%33 = load i32, i32* %4
%34 = sub nsw i32 %32, %33
%35 = sext i32 %34 to i64
%36 = mul i64 1, %35
%37 = add i64 %36, 1
%38 = trunc i64 %37 to i32
%39 = call i64 @malloc(i32 %38)
%40 = inttoptr i64 %39 to i8*
store i8* %40, i8** %7
store i32 0, i32* %8
br label %41
41: ; preds = %60, %31
%42 = load i32, i32* %8
%43 = load i32, i32* %5
%44 = load i32, i32* %4
%45 = sub nsw i32 %43, %44
%46 = add nsw i32 %45, 1
%47 = icmp slt i32 %42, %46
br i1 %47, label %48, label %63
48: ; preds = %41
%49 = load i8*, i8** %3
%50 = load i32, i32* %4
%51 = load i32, i32* %8
%52 = add nsw i32 %50, %51
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds i8, i8* %49, i64 %53
%55 = load i8, i8* %54
%56 = load i8*, i8** %7
%57 = load i32, i32* %8
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds i8, i8* %56, i64 %58
store i8 %55, i8* %59
br label %60
60: ; preds = %48
%61 = load i32, i32* %8
%62 = add nsw i32 %61, 1
store i32 %62, i32* %8
br label %41
63: ; preds = %41
%64 = load i8*, i8** %7
%65 = load i32, i32* %5
%66 = load i32, i32* %4
%67 = sub nsw i32 %65, %66
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds i8, i8* %64, i64 %68
store i8 0, i8* %69
%70 = load i8*, i8** %7
%71 = call i32 @atoi(i8* %70)
store i32 %71, i32* %9
%72 = load i8*, i8** %7
%73 = call i32 @free(i8* %72)
%74 = load i32, i32* %9
store i32 %74, i32* %2
br label %75
75: ; preds = %63, %12
%76 = load i32, i32* %2
ret i32 %76
}

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