; LLVM IR from nickmqb/muon :: bootstrap/mu.ll_Parser (tryParseExpressionLeaf__)

; Unoptimized IR (clang -disable-llvm-passes):
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

%struct.string__ = type { ptr, i32 }
%struct.tag_____IAllocator__ = type { ptr, ptr, ptr, ptr }
%struct.Node__ = type { i32, ptr }
%struct.tag_____UnaryOperatorExpression__ = type { ptr, %struct.Node__ }
%struct.tag_____NumberExpression__ = type { ptr, %struct.tag_____IntRange__, i32, %struct.tag_____Tag__, i64 }
%struct.tag_____IntRange__ = type { i32, i32 }
%struct.tag_____Tag__ = type { ptr, ptr }
%struct.tag_____StringExpression__ = type { ptr, %struct.string__, i32 }
%struct.tag_____ParenExpression__ = type { ptr, %struct.Node__, ptr }
%struct.tag_____ParserState__ = type { %struct.string__, i32, ptr, ptr, i32, i32, i32, i32, i32, ptr, %struct.tag_____IntRange__, i32, i32, ptr, i32, ptr, ptr, ptr }
%struct.tag_____Token__ = type { i32, %struct.string__, %struct.tag_____IntRange__, %struct.tag_____IntRange__, i32 }

@mu_____string193 = external dso_local global %struct.string__, align 8
@mu_____string2 = external dso_local global %struct.string__, align 8
@mu_____string297 = external dso_local global %struct.string__, align 8
@mu_____string160 = external dso_local global %struct.string__, align 8
@mu_____string75 = external dso_local global %struct.string__, align 8
@mu_____string191 = external dso_local global %struct.string__, align 8
@mu_____string190 = external dso_local global %struct.string__, align 8
@mu_____string192 = external dso_local global %struct.string__, align 8
@mu_____string303 = external dso_local global %struct.string__, align 8
@mu_____string74 = external dso_local global %struct.string__, align 8
@mu_____string302 = external dso_local global %struct.string__, align 8
@top_____currentAllocator__ = external dso_local thread_local global %struct.tag_____IAllocator__, align 8

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #0

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare nonnull ptr @llvm.threadlocal.address.p0(ptr nonnull) #1

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #0

; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: write)
declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1 immarg) #2

; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite)
declare void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64, i1 immarg) #3

; Function Attrs: nounwind uwtable
declare dso_local zeroext i8 @string__equals__(ptr, i32, ptr, i32) #4

; Function Attrs: nounwind uwtable
declare dso_local { ptr, i32 } @StringBuilder__toString__(ptr noundef) #4

; Function Attrs: nounwind uwtable
declare dso_local void @Parser__readToken__(ptr noundef) #4

; Function Attrs: nounwind uwtable
declare dso_local { i32, ptr } @Parser__tryParseExpression__(ptr noundef, i32 noundef, i8 noundef zeroext) #4

; Function Attrs: nounwind uwtable
declare dso_local void @Parser__expected__(ptr noundef, ptr, i32) #4

; Function Attrs: nounwind uwtable
define dso_local { i32, ptr } @Parser__tryParseExpressionLeaf__(ptr noundef %0, i8 noundef zeroext %1) #4 {
  %3 = alloca %struct.Node__, align 8
  %4 = alloca ptr, align 8
  %5 = alloca i8, align 1
  %6 = alloca i8, align 1
  %7 = alloca ptr, align 8
  %8 = alloca i32, align 4
  %9 = alloca ptr, align 8
  %10 = alloca %struct.tag_____UnaryOperatorExpression__, align 8
  %11 = alloca ptr, align 8
  %12 = alloca %struct.Node__, align 8
  %13 = alloca ptr, align 8
  %14 = alloca %struct.tag_____NumberExpression__, align 8
  %15 = alloca ptr, align 8
  %16 = alloca ptr, align 8
  %17 = alloca ptr, align 8
  %18 = alloca %struct.tag_____StringExpression__, align 8
  %19 = alloca %struct.string__, align 8
  %20 = alloca ptr, align 8
  %21 = alloca i8, align 1
  %22 = alloca i8, align 1
  %23 = alloca i8, align 1
  %24 = alloca ptr, align 8
  %25 = alloca %struct.tag_____UnaryOperatorExpression__, align 8
  %26 = alloca ptr, align 8
  %27 = alloca i8, align 1
  %28 = alloca %struct.Node__, align 8
  %29 = alloca i8, align 1
  %30 = alloca i8, align 1
  %31 = alloca i8, align 1
  %32 = alloca ptr, align 8
  %33 = alloca %struct.tag_____UnaryOperatorExpression__, align 8
  %34 = alloca ptr, align 8
  %35 = alloca %struct.Node__, align 8
  %36 = alloca ptr, align 8
  %37 = alloca %struct.tag_____ParenExpression__, align 8
  %38 = alloca ptr, align 8
  %39 = alloca %struct.Node__, align 8
  %40 = alloca i8, align 1
  store ptr %0, ptr %4, align 8, !tbaa !5
  store i8 %1, ptr %5, align 1, !tbaa !9
  %41 = load ptr, ptr %4, align 8, !tbaa !5
  %42 = getelementptr inbounds %struct.tag_____ParserState__, ptr %41, i32 0, i32 3
  %43 = load ptr, ptr %42, align 8, !tbaa !10
  %44 = getelementptr inbounds %struct.tag_____Token__, ptr %43, i32 0, i32 4
  %45 = load i32, ptr %44, align 8, !tbaa !15
  %46 = load ptr, ptr %4, align 8, !tbaa !5
  %47 = getelementptr inbounds %struct.tag_____ParserState__, ptr %46, i32 0, i32 5
  %48 = load i32, ptr %47, align 4, !tbaa !17
  %49 = icmp sle i32 %45, %48
  br i1 %49, label %50, label %53

50:                                               ; preds = %2
  %51 = getelementptr inbounds %struct.Node__, ptr %3, i32 0, i32 1
  store ptr null, ptr %51, align 8, !tbaa !18
  %52 = getelementptr inbounds %struct.Node__, ptr %3, i32 0, i32 0
  store i32 0, ptr %52, align 8, !tbaa !20
  br label %562

53:                                               ; preds = %2
  %54 = load ptr, ptr %4, align 8, !tbaa !5
  %55 = getelementptr inbounds %struct.tag_____ParserState__, ptr %54, i32 0, i32 3
  %56 = load ptr, ptr %55, align 8, !tbaa !10
  %57 = getelementptr inbounds %struct.tag_____Token__, ptr %56, i32 0, i32 0
  %58 = load i32, ptr %57, align 8, !tbaa !21
  %59 = icmp eq i32 %58, 0
  br i1 %59, label %60, label %143

60:                                               ; preds = %53
  call void @llvm.lifetime.start.p0(i64 1, ptr %6) #5
  %61 = load ptr, ptr %4, align 8, !tbaa !5
  %62 = getelementptr inbounds %struct.tag_____ParserState__, ptr %61, i32 0, i32 3
  %63 = load ptr, ptr %62, align 8, !tbaa !10
  %64 = getelementptr inbounds %struct.tag_____Token__, ptr %63, i32 0, i32 1
  %65 = getelementptr inbounds { ptr, i32 }, ptr %64, i32 0, i32 0
  %66 = load ptr, ptr %65, align 8
  %67 = getelementptr inbounds { ptr, i32 }, ptr %64, i32 0, i32 1
  %68 = load i32, ptr %67, align 8
  %69 = load ptr, ptr @mu_____string192, align 8
  %70 = load i32, ptr getelementptr inbounds ({ ptr, i32 }, ptr @mu_____string192, i32 0, i32 1), align 8
  %71 = call zeroext i8 @string__equals__(ptr %66, i32 %68, ptr %69, i32 %70)
  %72 = icmp ne i8 %71, 0
  %73 = xor i1 %72, true
  %74 = zext i1 %73 to i32
  %75 = trunc i32 %74 to i8
  store i8 %75, ptr %6, align 1, !tbaa !9
  %76 = load i8, ptr %6, align 1, !tbaa !9
  %77 = icmp ne i8 %76, 0
  br i1 %77, label %78, label %94

78:                                               ; preds = %60
  %79 = load ptr, ptr %4, align 8, !tbaa !5
  %80 = getelementptr inbounds %struct.tag_____ParserState__, ptr %79, i32 0, i32 3
  %81 = load ptr, ptr %80, align 8, !tbaa !10
  %82 = getelementptr inbounds %struct.tag_____Token__, ptr %81, i32 0, i32 1
  %83 = getelementptr inbounds { ptr, i32 }, ptr %82, i32 0, i32 0
  %84 = load ptr, ptr %83, align 8
  %85 = getelementptr inbounds { ptr, i32 }, ptr %82, i32 0, i32 1
  %86 = load i32, ptr %85, align 8
  %87 = load ptr, ptr @mu_____string193, align 8
  %88 = load i32, ptr getelementptr inbounds ({ ptr, i32 }, ptr @mu_____string193, i32 0, i32 1), align 8
  %89 = call zeroext i8 @string__equals__(ptr %84, i32 %86, ptr %87, i32 %88)
  %90 = icmp ne i8 %89, 0
  %91 = xor i1 %90, true
  %92 = zext i1 %91 to i32
  %93 = trunc i32 %92 to i8
  store i8 %93, ptr %6, align 1, !tbaa !9
  br label %94

94:                                               ; preds = %78, %60
  %95 = load i8, ptr %6, align 1, !tbaa !9
  %96 = icmp ne i8 %95, 0
  br i1 %96, label %97, label %110

97:                                               ; preds = %94
  call void @llvm.lifetime.start.p0(i64 8, ptr %7) #5
  %98 = load ptr, ptr %4, align 8, !tbaa !5
  %99 = getelementptr inbounds %struct.tag_____ParserState__, ptr %98, i32 0, i32 3
  %100 = load ptr, ptr %99, align 8, !tbaa !10
  store ptr %100, ptr %7, align 8, !tbaa !5
  %101 = load ptr, ptr %4, align 8, !tbaa !5
  call void @Parser__readToken__(ptr noundef %101)
  %102 = load ptr, ptr %7, align 8, !tbaa !5
  %103 = getelementptr inbounds %struct.Node__, ptr %3, i32 0, i32 1
  store ptr %102, ptr %103, align 8, !tbaa !18
  %104 = getelementptr inbounds %struct.Node__, ptr %3, i32 0, i32 1
  %105 = load ptr, ptr %104, align 8, !tbaa !18
  %106 = icmp ne ptr %105, null
  %107 = zext i1 %106 to i64
  %108 = select i1 %106, i32 21, i32 0
  %109 = getelementptr inbounds %struct.Node__, ptr %3, i32 0, i32 0
  store i32 %108, ptr %109, align 8, !tbaa !20
  store i32 1, ptr %8, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %7) #5
  br label %142

110:                                              ; preds = %94
  call void @llvm.lifetime.start.p0(i64 8, ptr %9) #5
  %111 = call align 8 ptr @llvm.threadlocal.address.p0(ptr align 8 @top_____currentAllocator__)
  %112 = getelementptr inbounds %struct.tag_____IAllocator__, ptr %111, i32 0, i32 1
  %113 = load ptr, ptr %112, align 8, !tbaa !22
  %114 = call align 8 ptr @llvm.threadlocal.address.p0(ptr align 8 @top_____currentAllocator__)
  %115 = getelementptr inbounds %struct.tag_____IAllocator__, ptr %114, i32 0, i32 0
  %116 = load ptr, ptr %115, align 8, !tbaa !24
  %117 = call ptr %113(ptr noundef %116, i64 noundef 24)
  store ptr %117, ptr %9, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 24, ptr %10) #5
  call void @llvm.memset.p0.i64(ptr align 8 %10, i8 0, i64 24, i1 false)
  %118 = load ptr, ptr %4, align 8, !tbaa !5
  %119 = getelementptr inbounds %struct.tag_____ParserState__, ptr %118, i32 0, i32 3
  %120 = load ptr, ptr %119, align 8, !tbaa !10
  %121 = getelementptr inbounds %struct.tag_____UnaryOperatorExpression__, ptr %10, i32 0, i32 0
  store ptr %120, ptr %121, align 8, !tbaa !25
  %122 = load ptr, ptr %9, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %122, ptr align 8 %10, i64 24, i1 false), !tbaa.struct !27
  call void @llvm.lifetime.start.p0(i64 8, ptr %11) #5
  %123 = load ptr, ptr %9, align 8, !tbaa !5
  store ptr %123, ptr %11, align 8, !tbaa !5
  %124 = load ptr, ptr %4, align 8, !tbaa !5
  call void @Parser__readToken__(ptr noundef %124)
  %125 = load ptr, ptr %11, align 8, !tbaa !5
  %126 = getelementptr inbounds %struct.tag_____UnaryOperatorExpression__, ptr %125, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 16, ptr %12) #5
  %127 = load ptr, ptr %4, align 8, !tbaa !5
  %128 = load i8, ptr %5, align 1, !tbaa !9
  %129 = call { i32, ptr } @Parser__tryParseExpression__(ptr noundef %127, i32 noundef 25, i8 noundef zeroext %128)
  %130 = getelementptr inbounds { i32, ptr }, ptr %12, i32 0, i32 0
  %131 = extractvalue { i32, ptr } %129, 0
  store i32 %131, ptr %130, align 8
  %132 = getelementptr inbounds { i32, ptr }, ptr %12, i32 0, i32 1
  %133 = extractvalue { i32, ptr } %129, 1
  store ptr %133, ptr %132, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %126, ptr align 8 %12, i64 16, i1 false), !tbaa.struct !29
  call void @llvm.lifetime.end.p0(i64 16, ptr %12) #5
  %134 = load ptr, ptr %11, align 8, !tbaa !5
  %135 = getelementptr inbounds %struct.Node__, ptr %3, i32 0, i32 1
  store ptr %134, ptr %135, align 8, !tbaa !18
  %136 = getelementptr inbounds %struct.Node__, ptr %3, i32 0, i32 1
  %137 = load ptr, ptr %136, align 8, !tbaa !18
  %138 = icmp ne ptr %137, null
  %139 = zext i1 %138 to i64
  %140 = select i1 %138, i32 9, i32 0
  %141 = getelementptr inbounds %struct.Node__, ptr %3, i32 0, i32 0
  store i32 %140, ptr %141, align 8, !tbaa !20
  store i32 1, ptr %8, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %11) #5
  call void @llvm.lifetime.end.p0(i64 24, ptr %10) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %9) #5
  br label %142

142:                                              ; preds = %110, %97
  call void @llvm.lifetime.end.p0(i64 1, ptr %6) #5
  br label %562

143:                                              ; preds = %53
  %144 = load ptr, ptr %4, align 8, !tbaa !5
  %145 = getelementptr inbounds %struct.tag_____ParserState__, ptr %144, i32 0, i32 3
  %146 = load ptr, ptr %145, align 8, !tbaa !10
  %147 = getelementptr inbounds %struct.tag_____Token__, ptr %146, i32 0, i32 0
  %148 = load i32, ptr %147, align 8, !tbaa !21
  %149 = icmp eq i32 %148, 1
  br i1 %149, label %150, label %180

150:                                              ; preds = %143
  call void @llvm.lifetime.start.p0(i64 8, ptr %13) #5
  %151 = call align 8 ptr @llvm.threadlocal.address.p0(ptr align 8 @top_____currentAllocator__)
  %152 = getelementptr inbounds %struct.tag_____IAllocator__, ptr %151, i32 0, i32 1
  %153 = load ptr, ptr %152, align 8, !tbaa !22
  %154 = call align 8 ptr @llvm.threadlocal.address.p0(ptr align 8 @top_____currentAllocator__)
  %155 = getelementptr inbounds %struct.tag_____IAllocator__, ptr %154, i32 0, i32 0
  %156 = load ptr, ptr %155, align 8, !tbaa !24
  %157 = call ptr %153(ptr noundef %156, i64 noundef 48)
  store ptr %157, ptr %13, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 48, ptr %14) #5
  call void @llvm.memset.p0.i64(ptr align 8 %14, i8 0, i64 48, i1 false)
  %158 = load ptr, ptr %4, align 8, !tbaa !5
  %159 = getelementptr inbounds %struct.tag_____ParserState__, ptr %158, i32 0, i32 3
  %160 = load ptr, ptr %159, align 8, !tbaa !10
  %161 = getelementptr inbounds %struct.tag_____NumberExpression__, ptr %14, i32 0, i32 0
  store ptr %160, ptr %161, align 8, !tbaa !30
  %162 = getelementptr inbounds %struct.tag_____NumberExpression__, ptr %14, i32 0, i32 1
  %163 = load ptr, ptr %4, align 8, !tbaa !5
  %164 = getelementptr inbounds %struct.tag_____ParserState__, ptr %163, i32 0, i32 10
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %162, ptr align 8 %164, i64 8, i1 false), !tbaa.struct !34
  %165 = load ptr, ptr %4, align 8, !tbaa !5
  %166 = getelementptr inbounds %struct.tag_____ParserState__, ptr %165, i32 0, i32 11
  %167 = load i32, ptr %166, align 8, !tbaa !35
  %168 = getelementptr inbounds %struct.tag_____NumberExpression__, ptr %14, i32 0, i32 2
  store i32 %167, ptr %168, align 8, !tbaa !36
  %169 = load ptr, ptr %13, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %169, ptr align 8 %14, i64 48, i1 false), !tbaa.struct !37
  call void @llvm.lifetime.start.p0(i64 8, ptr %15) #5
  %170 = load ptr, ptr %13, align 8, !tbaa !5
  store ptr %170, ptr %15, align 8, !tbaa !5
  %171 = load ptr, ptr %4, align 8, !tbaa !5
  call void @Parser__readToken__(ptr noundef %171)
  %172 = load ptr, ptr %15, align 8, !tbaa !5
  %173 = getelementptr inbounds %struct.Node__, ptr %3, i32 0, i32 1
  store ptr %172, ptr %173, align 8, !tbaa !18
  %174 = getelementptr inbounds %struct.Node__, ptr %3, i32 0, i32 1
  %175 = load ptr, ptr %174, align 8, !tbaa !18
  %176 = icmp ne ptr %175, null
  %177 = zext i1 %176 to i64
  %178 = select i1 %176, i32 19, i32 0
  %179 = getelementptr inbounds %struct.Node__, ptr %3, i32 0, i32 0
  store i32 %178, ptr %179, align 8, !tbaa !20
  store i32 1, ptr %8, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %15) #5
  call void @llvm.lifetime.end.p0(i64 48, ptr %14) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %13) #5
  br label %562

180:                                              ; preds = %143
  %181 = load ptr, ptr %4, align 8, !tbaa !5
  %182 = getelementptr inbounds %struct.tag_____ParserState__, ptr %181, i32 0, i32 3
  %183 = load ptr, ptr %182, align 8, !tbaa !10
  %184 = getelementptr inbounds %struct.tag_____Token__, ptr %183, i32 0, i32 0
  %185 = load i32, ptr %184, align 8, !tbaa !21
  %186 = icmp eq i32 %185, 3
  br i1 %186, label %187, label %200

187:                                              ; preds = %180
  call void @llvm.lifetime.start.p0(i64 8, ptr %16) #5
  %188 = load ptr, ptr %4, align 8, !tbaa !5
  %189 = getelementptr inbounds %struct.tag_____ParserState__, ptr %188, i32 0, i32 3
  %190 = load ptr, ptr %189, align 8, !tbaa !10
  store ptr %190, ptr %16, align 8, !tbaa !5
  %191 = load ptr, ptr %4, align 8, !tbaa !5
  call void @Parser__readToken__(ptr noundef %191)
  %192 = load ptr, ptr %16, align 8, !tbaa !5
  %193 = getelementptr inbounds %struct.Node__, ptr %3, i32 0, i32 1
  store ptr %192, ptr %193, align 8, !tbaa !18
  %194 = getelementptr inbounds %struct.Node__, ptr %3, i32 0, i32 1
  %195 = load ptr, ptr %194, align 8, !tbaa !18
  %196 = icmp ne ptr %195, null
  %197 = zext i1 %196 to i64
  %198 = select i1 %196, i32 21, i32 0
  %199 = getelementptr inbounds %struct.Node__, ptr %3, i32 0, i32 0
  store i32 %198, ptr %199, align 8, !tbaa !20
  store i32 1, ptr %8, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %16) #5
  br label %562

200:                                              ; preds = %180
  %201 = load ptr, ptr %4, align 8, !tbaa !5
  %202 = getelementptr inbounds %struct.tag_____ParserState__, ptr %201, i32 0, i32 3
  %203 = load ptr, ptr %202, align 8, !tbaa !10
  %204 = getelementptr inbounds %struct.tag_____Token__, ptr %203, i32 0, i32 0
  %205 = load i32, ptr %204, align 8, !tbaa !21
  %206 = icmp eq i32 %205, 2
  br i1 %206, label %207, label %239

207:                                              ; preds = %200
  call void @llvm.lifetime.start.p0(i64 8, ptr %17) #5
  %208 = call align 8 ptr @llvm.threadlocal.address.p0(ptr align 8 @top_____currentAllocator__)
  %209 = getelementptr inbounds %struct.tag_____IAllocator__, ptr %208, i32 0, i32 1
  %210 = load ptr, ptr %209, align 8, !tbaa !22
  %211 = call align 8 ptr @llvm.threadlocal.address.p0(ptr align 8 @top_____currentAllocator__)
  %212 = getelementptr inbounds %struct.tag_____IAllocator__, ptr %211, i32 0, i32 0
  %213 = load ptr, ptr %212, align 8, !tbaa !24
  %214 = call ptr %210(ptr noundef %213, i64 noundef 32)
  store ptr %214, ptr %17, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 32, ptr %18) #5
  call void @llvm.memset.p0.i64(ptr align 8 %18, i8 0, i64 32, i1 false)
  %215 = load ptr, ptr %4, align 8, !tbaa !5
  %216 = getelementptr inbounds %struct.tag_____ParserState__, ptr %215, i32 0, i32 3
  %217 = load ptr, ptr %216, align 8, !tbaa !10
  %218 = getelementptr inbounds %struct.tag_____StringExpression__, ptr %18, i32 0, i32 0
  store ptr %217, ptr %218, align 8, !tbaa !39
  %219 = getelementptr inbounds %struct.tag_____StringExpression__, ptr %18, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 16, ptr %19) #5
  %220 = load ptr, ptr %4, align 8, !tbaa !5
  %221 = getelementptr inbounds %struct.tag_____ParserState__, ptr %220, i32 0, i32 17
  %222 = load ptr, ptr %221, align 8, !tbaa !41
  %223 = call { ptr, i32 } @StringBuilder__toString__(ptr noundef %222)
  %224 = getelementptr inbounds { ptr, i32 }, ptr %19, i32 0, i32 0
  %225 = extractvalue { ptr, i32 } %223, 0
  store ptr %225, ptr %224, align 8
  %226 = getelementptr inbounds { ptr, i32 }, ptr %19, i32 0, i32 1
  %227 = extractvalue { ptr, i32 } %223, 1
  store i32 %227, ptr %226, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %219, ptr align 8 %19, i64 16, i1 false), !tbaa.struct !42
  call void @llvm.lifetime.end.p0(i64 16, ptr %19) #5
  %228 = load ptr, ptr %17, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %228, ptr align 8 %18, i64 32, i1 false), !tbaa.struct !43
  call void @llvm.lifetime.start.p0(i64 8, ptr %20) #5
  %229 = load ptr, ptr %17, align 8, !tbaa !5
  store ptr %229, ptr %20, align 8, !tbaa !5
  %230 = load ptr, ptr %4, align 8, !tbaa !5
  call void @Parser__readToken__(ptr noundef %230)
  %231 = load ptr, ptr %20, align 8, !tbaa !5
  %232 = getelementptr inbounds %struct.Node__, ptr %3, i32 0, i32 1
  store ptr %231, ptr %232, align 8, !tbaa !18
  %233 = getelementptr inbounds %struct.Node__, ptr %3, i32 0, i32 1
  %234 = load ptr, ptr %233, align 8, !tbaa !18
  %235 = icmp ne ptr %234, null
  %236 = zext i1 %235 to i64
  %237 = select i1 %235, i32 20, i32 0
  %238 = getelementptr inbounds %struct.Node__, ptr %3, i32 0, i32 0
  store i32 %237, ptr %238, align 8, !tbaa !20
  store i32 1, ptr %8, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %20) #5
  call void @llvm.lifetime.end.p0(i64 32, ptr %18) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %17) #5
  br label %562

239:                                              ; preds = %200
  call void @llvm.lifetime.start.p0(i64 1, ptr %21) #5
  %240 = load ptr, ptr %4, align 8, !tbaa !5
  %241 = getelementptr inbounds %struct.tag_____ParserState__, ptr %240, i32 0, i32 3
  %242 = load ptr, ptr %241, align 8, !tbaa !10
  %243 = getelementptr inbounds %struct.tag_____Token__, ptr %242, i32 0, i32 0
  %244 = load i32, ptr %243, align 8, !tbaa !21
  %245 = icmp eq i32 %244, 4
  %246 = zext i1 %245 to i32
  %247 = trunc i32 %246 to i8
  store i8 %247, ptr %21, align 1, !tbaa !9
  %248 = load i8, ptr %21, align 1, !tbaa !9
  %249 = icmp ne i8 %248, 0
  br i1 %249, label %250, label %278

250:                                              ; preds = %239
  call void @llvm.lifetime.start.p0(i64 1, ptr %22) #5
  %251 = load ptr, ptr %4, align 8, !tbaa !5
  %252 = getelementptr inbounds %struct.tag_____ParserState__, ptr %251, i32 0, i32 3
  %253 = load ptr, ptr %252, align 8, !tbaa !10
  %254 = getelementptr inbounds %struct.tag_____Token__, ptr %253, i32 0, i32 1
  %255 = getelementptr inbounds { ptr, i32 }, ptr %254, i32 0, i32 0
  %256 = load ptr, ptr %255, align 8
  %257 = getelementptr inbounds { ptr, i32 }, ptr %254, i32 0, i32 1
  %258 = load i32, ptr %257, align 8
  %259 = load ptr, ptr @mu_____string74, align 8
  %260 = load i32, ptr getelementptr inbounds ({ ptr, i32 }, ptr @mu_____string74, i32 0, i32 1), align 8
  %261 = call zeroext i8 @string__equals__(ptr %256, i32 %258, ptr %259, i32 %260)
  store i8 %261, ptr %22, align 1, !tbaa !9
  %262 = load i8, ptr %22, align 1, !tbaa !9
  %263 = icmp ne i8 %262, 0
  br i1 %263, label %276, label %264

264:                                              ; preds = %250
  %265 = load ptr, ptr %4, align 8, !tbaa !5
  %266 = getelementptr inbounds %struct.tag_____ParserState__, ptr %265, i32 0, i32 3
  %267 = load ptr, ptr %266, align 8, !tbaa !10
  %268 = getelementptr inbounds %struct.tag_____Token__, ptr %267, i32 0, i32 1
  %269 = getelementptr inbounds { ptr, i32 }, ptr %268, i32 0, i32 0
  %270 = load ptr, ptr %269, align 8
  %271 = getelementptr inbounds { ptr, i32 }, ptr %268, i32 0, i32 1
  %272 = load i32, ptr %271, align 8
  %273 = load ptr, ptr @mu_____string75, align 8
  %274 = load i32, ptr getelementptr inbounds ({ ptr, i32 }, ptr @mu_____string75, i32 0, i32 1), align 8
  %275 = call zeroext i8 @string__equals__(ptr %270, i32 %272, ptr %273, i32 %274)
  store i8 %275, ptr %22, align 1, !tbaa !9
  br label %276

276:                                              ; preds = %264, %250
  %277 = load i8, ptr %22, align 1, !tbaa !9
  store i8 %277, ptr %21, align 1, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 1, ptr %22) #5
  br label %278

278:                                              ; preds = %276, %239
  %279 = load i8, ptr %21, align 1, !tbaa !9
  %280 = icmp ne i8 %279, 0
  br i1 %280, label %281, label %288

281:                                              ; preds = %278
  %282 = load ptr, ptr %4, align 8, !tbaa !5
  %283 = call { i32, ptr } @Parser__tryParseType__(ptr noundef %282)
  %284 = getelementptr inbounds { i32, ptr }, ptr %3, i32 0, i32 0
  %285 = extractvalue { i32, ptr } %283, 0
  store i32 %285, ptr %284, align 8
  %286 = getelementptr inbounds { i32, ptr }, ptr %3, i32 0, i32 1
  %287 = extractvalue { i32, ptr } %283, 1
  store ptr %287, ptr %286, align 8
  store i32 1, ptr %8, align 4
  br label %561

288:                                              ; preds = %278
  call void @llvm.lifetime.start.p0(i64 1, ptr %23) #5
  %289 = load ptr, ptr %4, align 8, !tbaa !5
  %290 = getelementptr inbounds %struct.tag_____ParserState__, ptr %289, i32 0, i32 3
  %291 = load ptr, ptr %290, align 8, !tbaa !10
  %292 = getelementptr inbounds %struct.tag_____Token__, ptr %291, i32 0, i32 0
  %293 = load i32, ptr %292, align 8, !tbaa !21
  %294 = icmp eq i32 %293, 4
  %295 = zext i1 %294 to i32
  %296 = trunc i32 %295 to i8
  store i8 %296, ptr %23, align 1, !tbaa !9
  %297 = load i8, ptr %23, align 1, !tbaa !9
  %298 = icmp ne i8 %297, 0
  br i1 %298, label %299, label %311

299:                                              ; preds = %288
  %300 = load ptr, ptr %4, align 8, !tbaa !5
  %301 = getelementptr inbounds %struct.tag_____ParserState__, ptr %300, i32 0, i32 3
  %302 = load ptr, ptr %301, align 8, !tbaa !10
  %303 = getelementptr inbounds %struct.tag_____Token__, ptr %302, i32 0, i32 1
  %304 = getelementptr inbounds { ptr, i32 }, ptr %303, i32 0, i32 0
  %305 = load ptr, ptr %304, align 8
  %306 = getelementptr inbounds { ptr, i32 }, ptr %303, i32 0, i32 1
  %307 = load i32, ptr %306, align 8
  %308 = load ptr, ptr @mu_____string160, align 8
  %309 = load i32, ptr getelementptr inbounds ({ ptr, i32 }, ptr @mu_____string160, i32 0, i32 1), align 8
  %310 = call zeroext i8 @string__equals__(ptr %305, i32 %307, ptr %308, i32 %309)
  store i8 %310, ptr %23, align 1, !tbaa !9
  br label %311

311:                                              ; preds = %299, %288
  %312 = load i8, ptr %23, align 1, !tbaa !9
  %313 = icmp ne i8 %312, 0
  br i1 %313, label %314, label %381

314:                                              ; preds = %311
  call void @llvm.lifetime.start.p0(i64 8, ptr %24) #5
  %315 = call align 8 ptr @llvm.threadlocal.address.p0(ptr align 8 @top_____currentAllocator__)
  %316 = getelementptr inbounds %struct.tag_____IAllocator__, ptr %315, i32 0, i32 1
  %317 = load ptr, ptr %316, align 8, !tbaa !22
  %318 = call align 8 ptr @llvm.threadlocal.address.p0(ptr align 8 @top_____currentAllocator__)
  %319 = getelementptr inbounds %struct.tag_____IAllocator__, ptr %318, i32 0, i32 0
  %320 = load ptr, ptr %319, align 8, !tbaa !24
  %321 = call ptr %317(ptr noundef %320, i64 noundef 24)
  store ptr %321, ptr %24, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 24, ptr %25) #5
  call void @llvm.memset.p0.i64(ptr align 8 %25, i8 0, i64 24, i1 false)
  %322 = load ptr, ptr %4, align 8, !tbaa !5
  %323 = getelementptr inbounds %struct.tag_____ParserState__, ptr %322, i32 0, i32 3
  %324 = load ptr, ptr %323, align 8, !tbaa !10
  %325 = getelementptr inbounds %struct.tag_____UnaryOperatorExpression__, ptr %25, i32 0, i32 0
  store ptr %324, ptr %325, align 8, !tbaa !25
  %326 = load ptr, ptr %24, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %326, ptr align 8 %25, i64 24, i1 false), !tbaa.struct !27
  call void @llvm.lifetime.start.p0(i64 8, ptr %26) #5
  %327 = load ptr, ptr %24, align 8, !tbaa !5
  store ptr %327, ptr %26, align 8, !tbaa !5
  %328 = load ptr, ptr %4, align 8, !tbaa !5
  call void @Parser__readToken__(ptr noundef %328)
  call void @llvm.lifetime.start.p0(i64 1, ptr %27) #5
  %329 = load ptr, ptr %4, align 8, !tbaa !5
  %330 = getelementptr inbounds %struct.tag_____ParserState__, ptr %329, i32 0, i32 3
  %331 = load ptr, ptr %330, align 8, !tbaa !10
  %332 = getelementptr inbounds %struct.tag_____Token__, ptr %331, i32 0, i32 4
  %333 = load i32, ptr %332, align 8, !tbaa !15
  %334 = load ptr, ptr %4, align 8, !tbaa !5
  %335 = getelementptr inbounds %struct.tag_____ParserState__, ptr %334, i32 0, i32 5
  %336 = load i32, ptr %335, align 4, !tbaa !17
  %337 = icmp sgt i32 %333, %336
  %338 = zext i1 %337 to i32
  %339 = trunc i32 %338 to i8
  store i8 %339, ptr %27, align 1, !tbaa !9
  %340 = load i8, ptr %27, align 1, !tbaa !9
  %341 = icmp ne i8 %340, 0
  br i1 %341, label %342, label %351

342:                                              ; preds = %314
  %343 = load ptr, ptr %4, align 8, !tbaa !5
  %344 = getelementptr inbounds %struct.tag_____ParserState__, ptr %343, i32 0, i32 3
  %345 = load ptr, ptr %344, align 8, !tbaa !10
  %346 = getelementptr inbounds %struct.tag_____Token__, ptr %345, i32 0, i32 0
  %347 = load i32, ptr %346, align 8, !tbaa !21
  %348 = icmp eq i32 %347, 0
  %349 = zext i1 %348 to i32
  %350 = trunc i32 %349 to i8
  store i8 %350, ptr %27, align 1, !tbaa !9
  br label %351

351:                                              ; preds = %342, %314
  %352 = load i8, ptr %27, align 1, !tbaa !9
  %353 = icmp ne i8 %352, 0
  br i1 %353, label %354, label %368

354:                                              ; preds = %351
  call void @llvm.lifetime.start.p0(i64 16, ptr %28) #5
  %355 = load ptr, ptr %4, align 8, !tbaa !5
  %356 = getelementptr inbounds %struct.tag_____ParserState__, ptr %355, i32 0, i32 3
  %357 = load ptr, ptr %356, align 8, !tbaa !10
  %358 = getelementptr inbounds %struct.Node__, ptr %28, i32 0, i32 1
  store ptr %357, ptr %358, align 8, !tbaa !18
  %359 = getelementptr inbounds %struct.Node__, ptr %28, i32 0, i32 1
  %360 = load ptr, ptr %359, align 8, !tbaa !18
  %361 = icmp ne ptr %360, null
  %362 = zext i1 %361 to i64
  %363 = select i1 %361, i32 21, i32 0
  %364 = getelementptr inbounds %struct.Node__, ptr %28, i32 0, i32 0
  store i32 %363, ptr %364, align 8, !tbaa !20
  %365 = load ptr, ptr %26, align 8, !tbaa !5
  %366 = getelementptr inbounds %struct.tag_____UnaryOperatorExpression__, ptr %365, i32 0, i32 1
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %366, ptr align 8 %28, i64 16, i1 false), !tbaa.struct !29
  %367 = load ptr, ptr %4, align 8, !tbaa !5
  call void @Parser__readToken__(ptr noundef %367)
  call void @llvm.lifetime.end.p0(i64 16, ptr %28) #5
  br label %372

368:                                              ; preds = %351
  %369 = load ptr, ptr %4, align 8, !tbaa !5
  %370 = load ptr, ptr @mu_____string297, align 8
  %371 = load i32, ptr getelementptr inbounds ({ ptr, i32 }, ptr @mu_____string297, i32 0, i32 1), align 8
  call void @Parser__expected__(ptr noundef %369, ptr %370, i32 %371)
  br label %372

372:                                              ; preds = %368, %354
  %373 = load ptr, ptr %26, align 8, !tbaa !5
  %374 = getelementptr inbounds %struct.Node__, ptr %3, i32 0, i32 1
  store ptr %373, ptr %374, align 8, !tbaa !18
  %375 = getelementptr inbounds %struct.Node__, ptr %3, i32 0, i32 1
  %376 = load ptr, ptr %375, align 8, !tbaa !18
  %377 = icmp ne ptr %376, null
  %378 = zext i1 %377 to i64
  %379 = select i1 %377, i32 9, i32 0
  %380 = getelementptr inbounds %struct.Node__, ptr %3, i32 0, i32 0
  store i32 %379, ptr %380, align 8, !tbaa !20
  store i32 1, ptr %8, align 4
  call void @llvm.lifetime.end.p0(i64 1, ptr %27) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %26) #5
  call void @llvm.lifetime.end.p0(i64 24, ptr %25) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %24) #5
  br label %560

381:                                              ; preds = %311
  call void @llvm.lifetime.start.p0(i64 1, ptr %29) #5
  %382 = load ptr, ptr %4, align 8, !tbaa !5
  %383 = getelementptr inbounds %struct.tag_____ParserState__, ptr %382, i32 0, i32 3
  %384 = load ptr, ptr %383, align 8, !tbaa !10
  %385 = getelementptr inbounds %struct.tag_____Token__, ptr %384, i32 0, i32 0
  %386 = load i32, ptr %385, align 8, !tbaa !21
  %387 = icmp eq i32 %386, 4
  %388 = zext i1 %387 to i32
  %389 = trunc i32 %388 to i8
  store i8 %389, ptr %29, align 1, !tbaa !9
  %390 = load i8, ptr %29, align 1, !tbaa !9
  %391 = icmp ne i8 %390, 0
  br i1 %391, label %392, label %436

392:                                              ; preds = %381
  call void @llvm.lifetime.start.p0(i64 1, ptr %30) #5
  %393 = load ptr, ptr %4, align 8, !tbaa !5
  %394 = getelementptr inbounds %struct.tag_____ParserState__, ptr %393, i32 0, i32 3
  %395 = load ptr, ptr %394, align 8, !tbaa !10
  %396 = getelementptr inbounds %struct.tag_____Token__, ptr %395, i32 0, i32 1
  %397 = getelementptr inbounds { ptr, i32 }, ptr %396, i32 0, i32 0
  %398 = load ptr, ptr %397, align 8
  %399 = getelementptr inbounds { ptr, i32 }, ptr %396, i32 0, i32 1
  %400 = load i32, ptr %399, align 8
  %401 = load ptr, ptr @mu_____string2, align 8
  %402 = load i32, ptr getelementptr inbounds ({ ptr, i32 }, ptr @mu_____string2, i32 0, i32 1), align 8
  %403 = call zeroext i8 @string__equals__(ptr %398, i32 %400, ptr %401, i32 %402)
  store i8 %403, ptr %30, align 1, !tbaa !9
  %404 = load i8, ptr %30, align 1, !tbaa !9
  %405 = icmp ne i8 %404, 0
  br i1 %405, label %418, label %406

406:                                              ; preds = %392
  %407 = load ptr, ptr %4, align 8, !tbaa !5
  %408 = getelementptr inbounds %struct.tag_____ParserState__, ptr %407, i32 0, i32 3
  %409 = load ptr, ptr %408, align 8, !tbaa !10
  %410 = getelementptr inbounds %struct.tag_____Token__, ptr %409, i32 0, i32 1
  %411 = getelementptr inbounds { ptr, i32 }, ptr %410, i32 0, i32 0
  %412 = load ptr, ptr %411, align 8
  %413 = getelementptr inbounds { ptr, i32 }, ptr %410, i32 0, i32 1
  %414 = load i32, ptr %413, align 8
  %415 = load ptr, ptr @mu_____string190, align 8
  %416 = load i32, ptr getelementptr inbounds ({ ptr, i32 }, ptr @mu_____string190, i32 0, i32 1), align 8
  %417 = call zeroext i8 @string__equals__(ptr %412, i32 %414, ptr %415, i32 %416)
  store i8 %417, ptr %30, align 1, !tbaa !9
  br label %418

418:                                              ; preds = %406, %392
  call void @llvm.lifetime.start.p0(i64 1, ptr %31) #5
  %419 = load i8, ptr %30, align 1, !tbaa !9
  store i8 %419, ptr %31, align 1, !tbaa !9
  %420 = load i8, ptr %31, align 1, !tbaa !9
  %421 = icmp ne i8 %420, 0
  br i1 %421, label %434, label %422

422:                                              ; preds = %418
  %423 = load ptr, ptr %4, align 8, !tbaa !5
  %424 = getelementptr inbounds %struct.tag_____ParserState__, ptr %423, i32 0, i32 3
  %425 = load ptr, ptr %424, align 8, !tbaa !10
  %426 = getelementptr inbounds %struct.tag_____Token__, ptr %425, i32 0, i32 1
  %427 = getelementptr inbounds { ptr, i32 }, ptr %426, i32 0, i32 0
  %428 = load ptr, ptr %427, align 8
  %429 = getelementptr inbounds { ptr, i32 }, ptr %426, i32 0, i32 1
  %430 = load i32, ptr %429, align 8
  %431 = load ptr, ptr @mu_____string191, align 8
  %432 = load i32, ptr getelementptr inbounds ({ ptr, i32 }, ptr @mu_____string191, i32 0, i32 1), align 8
  %433 = call zeroext i8 @string__equals__(ptr %428, i32 %430, ptr %431, i32 %432)
  store i8 %433, ptr %31, align 1, !tbaa !9
  br label %434

434:                                              ; preds = %422, %418
  %435 = load i8, ptr %31, align 1, !tbaa !9
  store i8 %435, ptr %29, align 1, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 1, ptr %31) #5
  call void @llvm.lifetime.end.p0(i64 1, ptr %30) #5
  br label %436

436:                                              ; preds = %434, %381
  %437 = load i8, ptr %29, align 1, !tbaa !9
  %438 = icmp ne i8 %437, 0
  br i1 %438, label %439, label %471

439:                                              ; preds = %436
  call void @llvm.lifetime.start.p0(i64 8, ptr %32) #5
  %440 = call align 8 ptr @llvm.threadlocal.address.p0(ptr align 8 @top_____currentAllocator__)
  %441 = getelementptr inbounds %struct.tag_____IAllocator__, ptr %440, i32 0, i32 1
  %442 = load ptr, ptr %441, align 8, !tbaa !22
  %443 = call align 8 ptr @llvm.threadlocal.address.p0(ptr align 8 @top_____currentAllocator__)
  %444 = getelementptr inbounds %struct.tag_____IAllocator__, ptr %443, i32 0, i32 0
  %445 = load ptr, ptr %444, align 8, !tbaa !24
  %446 = call ptr %442(ptr noundef %445, i64 noundef 24)
  store ptr %446, ptr %32, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 24, ptr %33) #5
  call void @llvm.memset.p0.i64(ptr align 8 %33, i8 0, i64 24, i1 false)
  %447 = load ptr, ptr %4, align 8, !tbaa !5
  %448 = getelementptr inbounds %struct.tag_____ParserState__, ptr %447, i32 0, i32 3
  %449 = load ptr, ptr %448, align 8, !tbaa !10
  %450 = getelementptr inbounds %struct.tag_____UnaryOperatorExpression__, ptr %33, i32 0, i32 0
  store ptr %449, ptr %450, align 8, !tbaa !25
  %451 = load ptr, ptr %32, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %451, ptr align 8 %33, i64 24, i1 false), !tbaa.struct !27
  call void @llvm.lifetime.start.p0(i64 8, ptr %34) #5
  %452 = load ptr, ptr %32, align 8, !tbaa !5
  store ptr %452, ptr %34, align 8, !tbaa !5
  %453 = load ptr, ptr %4, align 8, !tbaa !5
  call void @Parser__readToken__(ptr noundef %453)
  %454 = load ptr, ptr %34, align 8, !tbaa !5
  %455 = getelementptr inbounds %struct.tag_____UnaryOperatorExpression__, ptr %454, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 16, ptr %35) #5
  %456 = load ptr, ptr %4, align 8, !tbaa !5
  %457 = load i8, ptr %5, align 1, !tbaa !9
  %458 = call { i32, ptr } @Parser__tryParseExpression__(ptr noundef %456, i32 noundef 25, i8 noundef zeroext %457)
  %459 = getelementptr inbounds { i32, ptr }, ptr %35, i32 0, i32 0
  %460 = extractvalue { i32, ptr } %458, 0
  store i32 %460, ptr %459, align 8
  %461 = getelementptr inbounds { i32, ptr }, ptr %35, i32 0, i32 1
  %462 = extractvalue { i32, ptr } %458, 1
  store ptr %462, ptr %461, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %455, ptr align 8 %35, i64 16, i1 false), !tbaa.struct !29
  call void @llvm.lifetime.end.p0(i64 16, ptr %35) #5
  %463 = load ptr, ptr %34, align 8, !tbaa !5
  %464 = getelementptr inbounds %struct.Node__, ptr %3, i32 0, i32 1
  store ptr %463, ptr %464, align 8, !tbaa !18
  %465 = getelementptr inbounds %struct.Node__, ptr %3, i32 0, i32 1
  %466 = load ptr, ptr %465, align 8, !tbaa !18
  %467 = icmp ne ptr %466, null
  %468 = zext i1 %467 to i64
  %469 = select i1 %467, i32 9, i32 0
  %470 = getelementptr inbounds %struct.Node__, ptr %3, i32 0, i32 0
  store i32 %469, ptr %470, align 8, !tbaa !20
  store i32 1, ptr %8, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %34) #5
  call void @llvm.lifetime.end.p0(i64 24, ptr %33) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %32) #5
  br label %559

471:                                              ; preds = %436
  %472 = load ptr, ptr %4, align 8, !tbaa !5
  %473 = getelementptr inbounds %struct.tag_____ParserState__, ptr %472, i32 0, i32 3
  %474 = load ptr, ptr %473, align 8, !tbaa !10
  %475 = getelementptr inbounds %struct.tag_____Token__, ptr %474, i32 0, i32 0
  %476 = load i32, ptr %475, align 8, !tbaa !21
  %477 = icmp eq i32 %476, 5
  br i1 %477, label %478, label %556

478:                                              ; preds = %471
  call void @llvm.lifetime.start.p0(i64 8, ptr %36) #5
  %479 = call align 8 ptr @llvm.threadlocal.address.p0(ptr align 8 @top_____currentAllocator__)
  %480 = getelementptr inbounds %struct.tag_____IAllocator__, ptr %479, i32 0, i32 1
  %481 = load ptr, ptr %480, align 8, !tbaa !22
  %482 = call align 8 ptr @llvm.threadlocal.address.p0(ptr align 8 @top_____currentAllocator__)
  %483 = getelementptr inbounds %struct.tag_____IAllocator__, ptr %482, i32 0, i32 0
  %484 = load ptr, ptr %483, align 8, !tbaa !24
  %485 = call ptr %481(ptr noundef %484, i64 noundef 32)
  store ptr %485, ptr %36, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 32, ptr %37) #5
  call void @llvm.memset.p0.i64(ptr align 8 %37, i8 0, i64 32, i1 false)
  %486 = load ptr, ptr %4, align 8, !tbaa !5
  %487 = getelementptr inbounds %struct.tag_____ParserState__, ptr %486, i32 0, i32 3
  %488 = load ptr, ptr %487, align 8, !tbaa !10
  %489 = getelementptr inbounds %struct.tag_____ParenExpression__, ptr %37, i32 0, i32 0
  store ptr %488, ptr %489, align 8, !tbaa !44
  %490 = load ptr, ptr %36, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %490, ptr align 8 %37, i64 32, i1 false), !tbaa.struct !46
  call void @llvm.lifetime.start.p0(i64 8, ptr %38) #5
  %491 = load ptr, ptr %36, align 8, !tbaa !5
  store ptr %491, ptr %38, align 8, !tbaa !5
  %492 = load ptr, ptr %4, align 8, !tbaa !5
  call void @Parser__readToken__(ptr noundef %492)
  %493 = load ptr, ptr %38, align 8, !tbaa !5
  %494 = getelementptr inbounds %struct.tag_____ParenExpression__, ptr %493, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 16, ptr %39) #5
  %495 = load ptr, ptr %4, align 8, !tbaa !5
  %496 = call { i32, ptr } @Parser__tryParseExpression__(ptr noundef %495, i32 noundef 0, i8 noundef zeroext 1)
  %497 = getelementptr inbounds { i32, ptr }, ptr %39, i32 0, i32 0
  %498 = extractvalue { i32, ptr } %496, 0
  store i32 %498, ptr %497, align 8
  %499 = getelementptr inbounds { i32, ptr }, ptr %39, i32 0, i32 1
  %500 = extractvalue { i32, ptr } %496, 1
  store ptr %500, ptr %499, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %494, ptr align 8 %39, i64 16, i1 false), !tbaa.struct !29
  call void @llvm.lifetime.end.p0(i64 16, ptr %39) #5
  %501 = load ptr, ptr %38, align 8, !tbaa !5
  %502 = getelementptr inbounds %struct.tag_____ParenExpression__, ptr %501, i32 0, i32 1
  %503 = getelementptr inbounds %struct.Node__, ptr %502, i32 0, i32 1
  %504 = load ptr, ptr %503, align 8, !tbaa !47
  %505 = icmp eq ptr %504, null
  br i1 %505, label %506, label %510

506:                                              ; preds = %478
  %507 = load ptr, ptr %4, align 8, !tbaa !5
  %508 = load ptr, ptr @mu_____string302, align 8
  %509 = load i32, ptr getelementptr inbounds ({ ptr, i32 }, ptr @mu_____string302, i32 0, i32 1), align 8
  call void @Parser__expected__(ptr noundef %507, ptr %508, i32 %509)
  br label %510

510:                                              ; preds = %506, %478
  call void @llvm.lifetime.start.p0(i64 1, ptr %40) #5
  %511 = load ptr, ptr %4, align 8, !tbaa !5
  %512 = getelementptr inbounds %struct.tag_____ParserState__, ptr %511, i32 0, i32 3
  %513 = load ptr, ptr %512, align 8, !tbaa !10
  %514 = getelementptr inbounds %struct.tag_____Token__, ptr %513, i32 0, i32 4
  %515 = load i32, ptr %514, align 8, !tbaa !15
  %516 = load ptr, ptr %4, align 8, !tbaa !5
  %517 = getelementptr inbounds %struct.tag_____ParserState__, ptr %516, i32 0, i32 5
  %518 = load i32, ptr %517, align 4, !tbaa !17
  %519 = icmp sge i32 %515, %518
  %520 = zext i1 %519 to i32
  %521 = trunc i32 %520 to i8
  store i8 %521, ptr %40, align 1, !tbaa !9
  %522 = load i8, ptr %40, align 1, !tbaa !9
  %523 = icmp ne i8 %522, 0
  br i1 %523, label %524, label %533

524:                                              ; preds = %510
  %525 = load ptr, ptr %4, align 8, !tbaa !5
  %526 = getelementptr inbounds %struct.tag_____ParserState__, ptr %525, i32 0, i32 3
  %527 = load ptr, ptr %526, align 8, !tbaa !10
  %528 = getelementptr inbounds %struct.tag_____Token__, ptr %527, i32 0, i32 0
  %529 = load i32, ptr %528, align 8, !tbaa !21
  %530 = icmp eq i32 %529, 6
  %531 = zext i1 %530 to i32
  %532 = trunc i32 %531 to i8
  store i8 %532, ptr %40, align 1, !tbaa !9
  br label %533

533:                                              ; preds = %524, %510
  %534 = load i8, ptr %40, align 1, !tbaa !9
  %535 = icmp ne i8 %534, 0
  br i1 %535, label %536, label %543

536:                                              ; preds = %533
  %537 = load ptr, ptr %4, align 8, !tbaa !5
  %538 = getelementptr inbounds %struct.tag_____ParserState__, ptr %537, i32 0, i32 3
  %539 = load ptr, ptr %538, align 8, !tbaa !10
  %540 = load ptr, ptr %38, align 8, !tbaa !5
  %541 = getelementptr inbounds %struct.tag_____ParenExpression__, ptr %540, i32 0, i32 2
  store ptr %539, ptr %541, align 8, !tbaa !48
  %542 = load ptr, ptr %4, align 8, !tbaa !5
  call void @Parser__readToken__(ptr noundef %542)
  br label %547

543:                                              ; preds = %533
  %544 = load ptr, ptr %4, align 8, !tbaa !5
  %545 = load ptr, ptr @mu_____string303, align 8
  %546 = load i32, ptr getelementptr inbounds ({ ptr, i32 }, ptr @mu_____string303, i32 0, i32 1), align 8
  call void @Parser__expected__(ptr noundef %544, ptr %545, i32 %546)
  br label %547

547:                                              ; preds = %543, %536
  %548 = load ptr, ptr %38, align 8, !tbaa !5
  %549 = getelementptr inbounds %struct.Node__, ptr %3, i32 0, i32 1
  store ptr %548, ptr %549, align 8, !tbaa !18
  %550 = getelementptr inbounds %struct.Node__, ptr %3, i32 0, i32 1
  %551 = load ptr, ptr %550, align 8, !tbaa !18
  %552 = icmp ne ptr %551, null
  %553 = zext i1 %552 to i64
  %554 = select i1 %552, i32 18, i32 0
  %555 = getelementptr inbounds %struct.Node__, ptr %3, i32 0, i32 0
  store i32 %554, ptr %555, align 8, !tbaa !20
  store i32 1, ptr %8, align 4
  call void @llvm.lifetime.end.p0(i64 1, ptr %40) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %38) #5
  call void @llvm.lifetime.end.p0(i64 32, ptr %37) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %36) #5
  br label %559

556:                                              ; preds = %471
  %557 = getelementptr inbounds %struct.Node__, ptr %3, i32 0, i32 1
  store ptr null, ptr %557, align 8, !tbaa !18
  %558 = getelementptr inbounds %struct.Node__, ptr %3, i32 0, i32 0
  store i32 0, ptr %558, align 8, !tbaa !20
  store i32 1, ptr %8, align 4
  br label %559

559:                                              ; preds = %556, %547, %439
  call void @llvm.lifetime.end.p0(i64 1, ptr %29) #5
  br label %560

560:                                              ; preds = %559, %372
  call void @llvm.lifetime.end.p0(i64 1, ptr %23) #5
  br label %561

561:                                              ; preds = %560, %281
  call void @llvm.lifetime.end.p0(i64 1, ptr %21) #5
  br label %562

562:                                              ; preds = %561, %207, %187, %150, %142, %50
  %563 = load { i32, ptr }, ptr %3, align 8
  ret { i32, ptr } %563
}

; Function Attrs: nounwind uwtable
declare dso_local { i32, ptr } @Parser__tryParseType__(ptr noundef) #4

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #2 = { nocallback nofree nounwind willreturn memory(argmem: write) }
attributes #3 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #4 = { nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #5 = { nounwind }

!llvm.module.flags = !{!0, !1, !2, !3}
!llvm.ident = !{!4}

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!7, !7, i64 0}
!10 = !{!11, !6, i64 32}
!11 = !{!"tag_____ParserState__", !12, i64 0, !13, i64 16, !6, i64 24, !6, i64 32, !13, i64 40, !13, i64 44, !13, i64 48, !13, i64 52, !13, i64 56, !6, i64 64, !14, i64 72, !13, i64 80, !13, i64 84, !6, i64 88, !13, i64 96, !6, i64 104, !6, i64 112, !6, i64 120}
!12 = !{!"", !6, i64 0, !13, i64 8}
!13 = !{!"int", !7, i64 0}
!14 = !{!"tag_____IntRange__", !13, i64 0, !13, i64 4}
!15 = !{!16, !13, i64 40}
!16 = !{!"tag_____Token__", !13, i64 0, !12, i64 8, !14, i64 24, !14, i64 32, !13, i64 40}
!17 = !{!11, !13, i64 44}
!18 = !{!19, !6, i64 8}
!19 = !{!"", !13, i64 0, !6, i64 8}
!20 = !{!19, !13, i64 0}
!21 = !{!16, !13, i64 0}
!22 = !{!23, !6, i64 8}
!23 = !{!"tag_____IAllocator__", !6, i64 0, !6, i64 8, !6, i64 16, !6, i64 24}
!24 = !{!23, !6, i64 0}
!25 = !{!26, !6, i64 0}
!26 = !{!"tag_____UnaryOperatorExpression__", !6, i64 0, !19, i64 8}
!27 = !{i64 0, i64 8, !5, i64 8, i64 4, !28, i64 16, i64 8, !5}
!28 = !{!13, !13, i64 0}
!29 = !{i64 0, i64 4, !28, i64 8, i64 8, !5}
!30 = !{!31, !6, i64 0}
!31 = !{!"tag_____NumberExpression__", !6, i64 0, !14, i64 8, !13, i64 16, !32, i64 24, !33, i64 40}
!32 = !{!"tag_____Tag__", !6, i64 0, !6, i64 8}
!33 = !{!"long", !7, i64 0}
!34 = !{i64 0, i64 4, !28, i64 4, i64 4, !28}
!35 = !{!11, !13, i64 80}
!36 = !{!31, !13, i64 16}
!37 = !{i64 0, i64 8, !5, i64 8, i64 4, !28, i64 12, i64 4, !28, i64 16, i64 4, !28, i64 24, i64 8, !5, i64 32, i64 8, !5, i64 40, i64 8, !38}
!38 = !{!33, !33, i64 0}
!39 = !{!40, !6, i64 0}
!40 = !{!"tag_____StringExpression__", !6, i64 0, !12, i64 8, !13, i64 24}
!41 = !{!11, !6, i64 120}
!42 = !{i64 0, i64 8, !5, i64 8, i64 4, !28}
!43 = !{i64 0, i64 8, !5, i64 8, i64 8, !5, i64 16, i64 4, !28, i64 24, i64 4, !28}
!44 = !{!45, !6, i64 0}
!45 = !{!"tag_____ParenExpression__", !6, i64 0, !19, i64 8, !6, i64 24}
!46 = !{i64 0, i64 8, !5, i64 8, i64 4, !28, i64 16, i64 8, !5, i64 24, i64 8, !5}
!47 = !{!45, !6, i64 16}
!48 = !{!45, !6, i64 24}


; Optimized IR (opt -passes='default<O3>'):
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

%struct.string__ = type { ptr, i32 }
%struct.tag_____IAllocator__ = type { ptr, ptr, ptr, ptr }

@mu_____string193 = external dso_local local_unnamed_addr global %struct.string__, align 8
@mu_____string2 = external dso_local local_unnamed_addr global %struct.string__, align 8
@mu_____string297 = external dso_local local_unnamed_addr global %struct.string__, align 8
@mu_____string160 = external dso_local local_unnamed_addr global %struct.string__, align 8
@mu_____string75 = external dso_local local_unnamed_addr global %struct.string__, align 8
@mu_____string191 = external dso_local local_unnamed_addr global %struct.string__, align 8
@mu_____string190 = external dso_local local_unnamed_addr global %struct.string__, align 8
@mu_____string192 = external dso_local local_unnamed_addr global %struct.string__, align 8
@mu_____string303 = external dso_local local_unnamed_addr global %struct.string__, align 8
@mu_____string74 = external dso_local local_unnamed_addr global %struct.string__, align 8
@mu_____string302 = external dso_local local_unnamed_addr global %struct.string__, align 8
@top_____currentAllocator__ = external dso_local thread_local local_unnamed_addr global %struct.tag_____IAllocator__, align 8

; Function Attrs: mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare nonnull ptr @llvm.threadlocal.address.p0(ptr nonnull) #0

; Function Attrs: mustprogress nocallback nofree nounwind willreturn memory(argmem: write)
declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1 immarg) #1

; Function Attrs: nounwind uwtable
declare dso_local zeroext i8 @string__equals__(ptr, i32, ptr, i32) local_unnamed_addr #2

; Function Attrs: nounwind uwtable
declare dso_local { ptr, i32 } @StringBuilder__toString__(ptr noundef) local_unnamed_addr #2

; Function Attrs: nounwind uwtable
declare dso_local void @Parser__readToken__(ptr noundef) local_unnamed_addr #2

; Function Attrs: nounwind uwtable
declare dso_local { i32, ptr } @Parser__tryParseExpression__(ptr noundef, i32 noundef, i8 noundef zeroext) local_unnamed_addr #2

; Function Attrs: nounwind uwtable
declare dso_local void @Parser__expected__(ptr noundef, ptr, i32) local_unnamed_addr #2

; Function Attrs: nounwind uwtable
define dso_local { i32, ptr } @Parser__tryParseExpressionLeaf__(ptr noundef %0, i8 noundef zeroext %1) local_unnamed_addr #2 {
  %3 = getelementptr inbounds i8, ptr %0, i64 32
  %4 = load ptr, ptr %3, align 8, !tbaa !5
  %5 = getelementptr inbounds i8, ptr %4, i64 40
  %6 = load i32, ptr %5, align 8, !tbaa !13
  %7 = getelementptr inbounds i8, ptr %0, i64 44
  %8 = load i32, ptr %7, align 4, !tbaa !15
  %.not = icmp sgt i32 %6, %8
  br i1 %.not, label %9, label %177

9:                                                ; preds = %2
  %10 = load i32, ptr %4, align 8, !tbaa !16
  switch i32 %10, label %.thread [
    i32 0, label %11
    i32 1, label %40
    i32 3, label %51
    i32 2, label %52
    i32 4, label %64
  ]

11:                                               ; preds = %9
  %12 = getelementptr inbounds i8, ptr %4, i64 8
  %13 = load ptr, ptr %12, align 8
  %14 = getelementptr inbounds i8, ptr %4, i64 16
  %15 = load i32, ptr %14, align 8
  %16 = load ptr, ptr @mu_____string192, align 8
  %17 = load i32, ptr getelementptr inbounds (i8, ptr @mu_____string192, i64 8), align 8
  %18 = tail call zeroext i8 @string__equals__(ptr %13, i32 %15, ptr %16, i32 %17)
  %.not160 = icmp eq i8 %18, 0
  br i1 %.not160, label %19, label %.critedge

19:                                               ; preds = %11
  %20 = load ptr, ptr %3, align 8, !tbaa !5
  %21 = getelementptr inbounds i8, ptr %20, i64 8
  %22 = load ptr, ptr %21, align 8
  %23 = getelementptr inbounds i8, ptr %20, i64 16
  %24 = load i32, ptr %23, align 8
  %25 = load ptr, ptr @mu_____string193, align 8
  %26 = load i32, ptr getelementptr inbounds (i8, ptr @mu_____string193, i64 8), align 8
  %27 = tail call zeroext i8 @string__equals__(ptr %22, i32 %24, ptr %25, i32 %26)
  %.not161.not = icmp eq i8 %27, 0
  br i1 %.not161.not, label %28, label %.critedge

28:                                               ; preds = %19
  %29 = load ptr, ptr %3, align 8, !tbaa !5
  tail call void @Parser__readToken__(ptr noundef nonnull %0)
  %.not163 = icmp eq ptr %29, null
  %30 = select i1 %.not163, i32 0, i32 21
  br label %177

.critedge:                                        ; preds = %11, %19
  %31 = tail call align 8 ptr @llvm.threadlocal.address.p0(ptr align 8 @top_____currentAllocator__)
  %32 = getelementptr inbounds i8, ptr %31, i64 8
  %33 = load ptr, ptr %32, align 8, !tbaa !17
  %34 = load ptr, ptr %31, align 8, !tbaa !19
  %35 = tail call ptr %33(ptr noundef %34, i64 noundef 24) #3
  %36 = load ptr, ptr %3, align 8, !tbaa !5
  store ptr %36, ptr %35, align 8, !tbaa !20
  %.sroa.563.0..sroa_idx = getelementptr inbounds i8, ptr %35, i64 8
  tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %.sroa.563.0..sroa_idx, i8 0, i64 16, i1 false)
  tail call void @Parser__readToken__(ptr noundef nonnull %0)
  %37 = tail call { i32, ptr } @Parser__tryParseExpression__(ptr noundef nonnull %0, i32 noundef 25, i8 noundef zeroext %1)
  %38 = extractvalue { i32, ptr } %37, 0
  %39 = extractvalue { i32, ptr } %37, 1
  store i32 %38, ptr %.sroa.563.0..sroa_idx, align 8, !tbaa !21
  %.sroa.459.0..sroa_idx = getelementptr inbounds i8, ptr %35, i64 16
  store ptr %39, ptr %.sroa.459.0..sroa_idx, align 8, !tbaa !20
  br label %177

40:                                               ; preds = %9
  %41 = tail call align 8 ptr @llvm.threadlocal.address.p0(ptr align 8 @top_____currentAllocator__)
  %42 = getelementptr inbounds i8, ptr %41, i64 8
  %43 = load ptr, ptr %42, align 8, !tbaa !17
  %44 = load ptr, ptr %41, align 8, !tbaa !19
  %45 = tail call ptr %43(ptr noundef %44, i64 noundef 48) #3
  %46 = load ptr, ptr %3, align 8, !tbaa !5
  %47 = getelementptr inbounds i8, ptr %0, i64 72
  %48 = load i64, ptr %47, align 8
  %49 = getelementptr inbounds i8, ptr %0, i64 80
  %50 = load i32, ptr %49, align 8, !tbaa !22
  store ptr %46, ptr %45, align 8, !tbaa !20
  %.sroa.552.0..sroa_idx = getelementptr inbounds i8, ptr %45, i64 8
  store i64 %48, ptr %.sroa.552.0..sroa_idx, align 8
  %.sroa.653.0..sroa_idx = getelementptr inbounds i8, ptr %45, i64 16
  store i32 %50, ptr %.sroa.653.0..sroa_idx, align 8, !tbaa !21
  %.sroa.754.0..sroa_idx = getelementptr inbounds i8, ptr %45, i64 20
  tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 4 dereferenceable(28) %.sroa.754.0..sroa_idx, i8 0, i64 28, i1 false)
  tail call void @Parser__readToken__(ptr noundef nonnull %0)
  br label %177

51:                                               ; preds = %9
  tail call void @Parser__readToken__(ptr noundef nonnull %0)
  br label %177

52:                                               ; preds = %9
  %53 = tail call align 8 ptr @llvm.threadlocal.address.p0(ptr align 8 @top_____currentAllocator__)
  %54 = getelementptr inbounds i8, ptr %53, i64 8
  %55 = load ptr, ptr %54, align 8, !tbaa !17
  %56 = load ptr, ptr %53, align 8, !tbaa !19
  %57 = tail call ptr %55(ptr noundef %56, i64 noundef 32) #3
  %58 = load ptr, ptr %3, align 8, !tbaa !5
  %59 = getelementptr inbounds i8, ptr %0, i64 120
  %60 = load ptr, ptr %59, align 8, !tbaa !23
  %61 = tail call { ptr, i32 } @StringBuilder__toString__(ptr noundef %60)
  %62 = extractvalue { ptr, i32 } %61, 0
  %63 = extractvalue { ptr, i32 } %61, 1
  store ptr %58, ptr %57, align 8, !tbaa !20
  %.sroa.546.0..sroa_idx = getelementptr inbounds i8, ptr %57, i64 8
  store ptr %62, ptr %.sroa.546.0..sroa_idx, align 8, !tbaa !20
  %.sroa.6.0..sroa_idx = getelementptr inbounds i8, ptr %57, i64 16
  store i32 %63, ptr %.sroa.6.0..sroa_idx, align 8, !tbaa !21
  %.sroa.8.0..sroa_idx = getelementptr inbounds i8, ptr %57, i64 24
  store i64 0, ptr %.sroa.8.0..sroa_idx, align 8
  tail call void @Parser__readToken__(ptr noundef nonnull %0)
  br label %177

64:                                               ; preds = %9
  %65 = getelementptr inbounds i8, ptr %4, i64 8
  %66 = load ptr, ptr %65, align 8
  %67 = getelementptr inbounds i8, ptr %4, i64 16
  %68 = load i32, ptr %67, align 8
  %69 = load ptr, ptr @mu_____string74, align 8
  %70 = load i32, ptr getelementptr inbounds (i8, ptr @mu_____string74, i64 8), align 8
  %71 = tail call zeroext i8 @string__equals__(ptr %66, i32 %68, ptr %69, i32 %70)
  %.not150 = icmp eq i8 %71, 0
  br i1 %.not150, label %72, label %.thread176

72:                                               ; preds = %64
  %73 = load ptr, ptr %3, align 8, !tbaa !5
  %74 = getelementptr inbounds i8, ptr %73, i64 8
  %75 = load ptr, ptr %74, align 8
  %76 = getelementptr inbounds i8, ptr %73, i64 16
  %77 = load i32, ptr %76, align 8
  %78 = load ptr, ptr @mu_____string75, align 8
  %79 = load i32, ptr getelementptr inbounds (i8, ptr @mu_____string75, i64 8), align 8
  %80 = tail call zeroext i8 @string__equals__(ptr %75, i32 %77, ptr %78, i32 %79)
  %.not151 = icmp eq i8 %80, 0
  br i1 %.not151, label %..thread_crit_edge, label %.thread176

..thread_crit_edge:                               ; preds = %72
  %.pre = load ptr, ptr %3, align 8, !tbaa !5
  %.pre181 = load i32, ptr %.pre, align 8, !tbaa !16
  br label %.thread

.thread176:                                       ; preds = %64, %72
  %81 = tail call { i32, ptr } @Parser__tryParseType__(ptr noundef nonnull %0)
  %82 = extractvalue { i32, ptr } %81, 0
  %83 = extractvalue { i32, ptr } %81, 1
  br label %177

.thread:                                          ; preds = %..thread_crit_edge, %9
  %84 = phi i32 [ %.pre181, %..thread_crit_edge ], [ %10, %9 ]
  %85 = phi ptr [ %.pre, %..thread_crit_edge ], [ %4, %9 ]
  %86 = icmp eq i32 %84, 4
  br i1 %86, label %87, label %.critedge170

87:                                               ; preds = %.thread
  %88 = getelementptr inbounds i8, ptr %85, i64 8
  %89 = load ptr, ptr %88, align 8
  %90 = getelementptr inbounds i8, ptr %85, i64 16
  %91 = load i32, ptr %90, align 8
  %92 = load ptr, ptr @mu_____string160, align 8
  %93 = load i32, ptr getelementptr inbounds (i8, ptr @mu_____string160, i64 8), align 8
  %94 = tail call zeroext i8 @string__equals__(ptr %89, i32 %91, ptr %92, i32 %93)
  %95 = icmp eq i8 %94, 0
  br i1 %95, label %.critedge165, label %96

96:                                               ; preds = %87
  %97 = tail call align 8 ptr @llvm.threadlocal.address.p0(ptr align 8 @top_____currentAllocator__)
  %98 = getelementptr inbounds i8, ptr %97, i64 8
  %99 = load ptr, ptr %98, align 8, !tbaa !17
  %100 = load ptr, ptr %97, align 8, !tbaa !19
  %101 = tail call ptr %99(ptr noundef %100, i64 noundef 24) #3
  %102 = load ptr, ptr %3, align 8, !tbaa !5
  store ptr %102, ptr %101, align 8, !tbaa !20
  %.sroa.532.0..sroa_idx = getelementptr inbounds i8, ptr %101, i64 8
  tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %.sroa.532.0..sroa_idx, i8 0, i64 16, i1 false)
  tail call void @Parser__readToken__(ptr noundef nonnull %0)
  %103 = load ptr, ptr %3, align 8, !tbaa !5
  %104 = getelementptr inbounds i8, ptr %103, i64 40
  %105 = load i32, ptr %104, align 8, !tbaa !13
  %106 = load i32, ptr %7, align 4, !tbaa !15
  %107 = icmp sgt i32 %105, %106
  br i1 %107, label %108, label %.critedge167

108:                                              ; preds = %96
  %109 = load i32, ptr %103, align 8, !tbaa !16
  %.not179 = icmp eq i32 %109, 0
  br i1 %.not179, label %110, label %.critedge167

110:                                              ; preds = %108
  store i32 21, ptr %.sroa.532.0..sroa_idx, align 8, !tbaa !21
  %.sroa.426.0..sroa_idx = getelementptr inbounds i8, ptr %101, i64 16
  store ptr %103, ptr %.sroa.426.0..sroa_idx, align 8, !tbaa !20
  tail call void @Parser__readToken__(ptr noundef nonnull %0)
  br label %177

.critedge167:                                     ; preds = %96, %108
  %111 = load ptr, ptr @mu_____string297, align 8
  %112 = load i32, ptr getelementptr inbounds (i8, ptr @mu_____string297, i64 8), align 8
  tail call void @Parser__expected__(ptr noundef nonnull %0, ptr %111, i32 %112)
  br label %177

.critedge165:                                     ; preds = %87
  %.pre182 = load ptr, ptr %3, align 8, !tbaa !5
  %.pre183 = load i32, ptr %.pre182, align 8, !tbaa !16
  %113 = icmp eq i32 %.pre183, 4
  br i1 %113, label %114, label %.critedge170

114:                                              ; preds = %.critedge165
  %115 = getelementptr inbounds i8, ptr %.pre182, i64 8
  %116 = load ptr, ptr %115, align 8
  %117 = getelementptr inbounds i8, ptr %.pre182, i64 16
  %118 = load i32, ptr %117, align 8
  %119 = load ptr, ptr @mu_____string2, align 8
  %120 = load i32, ptr getelementptr inbounds (i8, ptr @mu_____string2, i64 8), align 8
  %121 = tail call zeroext i8 @string__equals__(ptr %116, i32 %118, ptr %119, i32 %120)
  %.not153 = icmp eq i8 %121, 0
  br i1 %.not153, label %122, label %.critedge171

122:                                              ; preds = %114
  %123 = load ptr, ptr %3, align 8, !tbaa !5
  %124 = getelementptr inbounds i8, ptr %123, i64 8
  %125 = load ptr, ptr %124, align 8
  %126 = getelementptr inbounds i8, ptr %123, i64 16
  %127 = load i32, ptr %126, align 8
  %128 = load ptr, ptr @mu_____string190, align 8
  %129 = load i32, ptr getelementptr inbounds (i8, ptr @mu_____string190, i64 8), align 8
  %130 = tail call zeroext i8 @string__equals__(ptr %125, i32 %127, ptr %128, i32 %129)
  %131 = icmp eq i8 %130, 0
  br i1 %131, label %.critedge169, label %.critedge171

.critedge169:                                     ; preds = %122
  %132 = load ptr, ptr %3, align 8, !tbaa !5
  %133 = getelementptr inbounds i8, ptr %132, i64 8
  %134 = load ptr, ptr %133, align 8
  %135 = getelementptr inbounds i8, ptr %132, i64 16
  %136 = load i32, ptr %135, align 8
  %137 = load ptr, ptr @mu_____string191, align 8
  %138 = load i32, ptr getelementptr inbounds (i8, ptr @mu_____string191, i64 8), align 8
  %139 = tail call zeroext i8 @string__equals__(ptr %134, i32 %136, ptr %137, i32 %138)
  %140 = icmp eq i8 %139, 0
  br i1 %140, label %.critedge169..critedge170_crit_edge, label %.critedge171

.critedge169..critedge170_crit_edge:              ; preds = %.critedge169
  %.pre184 = load ptr, ptr %3, align 8, !tbaa !5
  %.pre185 = load i32, ptr %.pre184, align 8, !tbaa !16
  br label %.critedge170

.critedge171:                                     ; preds = %122, %114, %.critedge169
  %141 = tail call align 8 ptr @llvm.threadlocal.address.p0(ptr align 8 @top_____currentAllocator__)
  %142 = getelementptr inbounds i8, ptr %141, i64 8
  %143 = load ptr, ptr %142, align 8, !tbaa !17
  %144 = load ptr, ptr %141, align 8, !tbaa !19
  %145 = tail call ptr %143(ptr noundef %144, i64 noundef 24) #3
  %146 = load ptr, ptr %3, align 8, !tbaa !5
  store ptr %146, ptr %145, align 8, !tbaa !20
  %.sroa.515.0..sroa_idx = getelementptr inbounds i8, ptr %145, i64 8
  tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %.sroa.515.0..sroa_idx, i8 0, i64 16, i1 false)
  tail call void @Parser__readToken__(ptr noundef nonnull %0)
  %147 = tail call { i32, ptr } @Parser__tryParseExpression__(ptr noundef nonnull %0, i32 noundef 25, i8 noundef zeroext %1)
  %148 = extractvalue { i32, ptr } %147, 0
  %149 = extractvalue { i32, ptr } %147, 1
  store i32 %148, ptr %.sroa.515.0..sroa_idx, align 8, !tbaa !21
  %.sroa.411.0..sroa_idx = getelementptr inbounds i8, ptr %145, i64 16
  store ptr %149, ptr %.sroa.411.0..sroa_idx, align 8, !tbaa !20
  br label %177

.critedge170:                                     ; preds = %.thread, %.critedge169..critedge170_crit_edge, %.critedge165
  %150 = phi i32 [ %.pre185, %.critedge169..critedge170_crit_edge ], [ %.pre183, %.critedge165 ], [ %84, %.thread ]
  %151 = icmp eq i32 %150, 5
  br i1 %151, label %152, label %177

152:                                              ; preds = %.critedge170
  %153 = tail call align 8 ptr @llvm.threadlocal.address.p0(ptr align 8 @top_____currentAllocator__)
  %154 = getelementptr inbounds i8, ptr %153, i64 8
  %155 = load ptr, ptr %154, align 8, !tbaa !17
  %156 = load ptr, ptr %153, align 8, !tbaa !19
  %157 = tail call ptr %155(ptr noundef %156, i64 noundef 32) #3
  %158 = load ptr, ptr %3, align 8, !tbaa !5
  store ptr %158, ptr %157, align 8, !tbaa !20
  %.sroa.5.0..sroa_idx = getelementptr inbounds i8, ptr %157, i64 8
  tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(24) %.sroa.5.0..sroa_idx, i8 0, i64 24, i1 false)
  tail call void @Parser__readToken__(ptr noundef nonnull %0)
  %159 = tail call { i32, ptr } @Parser__tryParseExpression__(ptr noundef nonnull %0, i32 noundef 0, i8 noundef zeroext 1)
  %160 = extractvalue { i32, ptr } %159, 0
  %161 = extractvalue { i32, ptr } %159, 1
  store i32 %160, ptr %.sroa.5.0..sroa_idx, align 8, !tbaa !21
  %.sroa.42.0..sroa_idx = getelementptr inbounds i8, ptr %157, i64 16
  store ptr %161, ptr %.sroa.42.0..sroa_idx, align 8, !tbaa !20
  %162 = icmp eq ptr %161, null
  br i1 %162, label %163, label %166

163:                                              ; preds = %152
  %164 = load ptr, ptr @mu_____string302, align 8
  %165 = load i32, ptr getelementptr inbounds (i8, ptr @mu_____string302, i64 8), align 8
  tail call void @Parser__expected__(ptr noundef nonnull %0, ptr %164, i32 %165)
  br label %166

166:                                              ; preds = %163, %152
  %167 = load ptr, ptr %3, align 8, !tbaa !5
  %168 = getelementptr inbounds i8, ptr %167, i64 40
  %169 = load i32, ptr %168, align 8, !tbaa !13
  %170 = load i32, ptr %7, align 4, !tbaa !15
  %.not156 = icmp slt i32 %169, %170
  br i1 %.not156, label %.critedge173, label %171

171:                                              ; preds = %166
  %172 = load i32, ptr %167, align 8, !tbaa !16
  %.not180 = icmp eq i32 %172, 6
  br i1 %.not180, label %173, label %.critedge173

173:                                              ; preds = %171
  %174 = getelementptr inbounds i8, ptr %157, i64 24
  store ptr %167, ptr %174, align 8, !tbaa !24
  tail call void @Parser__readToken__(ptr noundef nonnull %0)
  br label %177

.critedge173:                                     ; preds = %166, %171
  %175 = load ptr, ptr @mu_____string303, align 8
  %176 = load i32, ptr getelementptr inbounds (i8, ptr @mu_____string303, i64 8), align 8
  tail call void @Parser__expected__(ptr noundef nonnull %0, ptr %175, i32 %176)
  br label %177

177:                                              ; preds = %173, %.critedge173, %110, %.critedge167, %.thread176, %.critedge171, %.critedge170, %28, %.critedge, %2, %52, %51, %40
  %.sroa.0125.4 = phi i32 [ 19, %40 ], [ 21, %51 ], [ 20, %52 ], [ 0, %2 ], [ %30, %28 ], [ 9, %.critedge ], [ %82, %.thread176 ], [ 9, %.critedge171 ], [ 0, %.critedge170 ], [ 9, %.critedge167 ], [ 9, %110 ], [ 18, %.critedge173 ], [ 18, %173 ]
  %.sroa.12.4 = phi ptr [ %45, %40 ], [ %4, %51 ], [ %57, %52 ], [ null, %2 ], [ %29, %28 ], [ %35, %.critedge ], [ %83, %.thread176 ], [ %145, %.critedge171 ], [ null, %.critedge170 ], [ %101, %.critedge167 ], [ %101, %110 ], [ %157, %.critedge173 ], [ %157, %173 ]
  %.fca.0.insert = insertvalue { i32, ptr } poison, i32 %.sroa.0125.4, 0
  %.fca.1.insert = insertvalue { i32, ptr } %.fca.0.insert, ptr %.sroa.12.4, 1
  ret { i32, ptr } %.fca.1.insert
}

; Function Attrs: nounwind uwtable
declare dso_local { i32, ptr } @Parser__tryParseType__(ptr noundef) local_unnamed_addr #2

attributes #0 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #1 = { mustprogress nocallback nofree nounwind willreturn memory(argmem: write) }
attributes #2 = { nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { nounwind }

!llvm.module.flags = !{!0, !1, !2, !3}
!llvm.ident = !{!4}

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !8, i64 32}
!6 = !{!"tag_____ParserState__", !7, i64 0, !11, i64 16, !8, i64 24, !8, i64 32, !11, i64 40, !11, i64 44, !11, i64 48, !11, i64 52, !11, i64 56, !8, i64 64, !12, i64 72, !11, i64 80, !11, i64 84, !8, i64 88, !11, i64 96, !8, i64 104, !8, i64 112, !8, i64 120}
!7 = !{!"", !8, i64 0, !11, i64 8}
!8 = !{!"any pointer", !9, i64 0}
!9 = !{!"omnipotent char", !10, i64 0}
!10 = !{!"Simple C/C++ TBAA"}
!11 = !{!"int", !9, i64 0}
!12 = !{!"tag_____IntRange__", !11, i64 0, !11, i64 4}
!13 = !{!14, !11, i64 40}
!14 = !{!"tag_____Token__", !11, i64 0, !7, i64 8, !12, i64 24, !12, i64 32, !11, i64 40}
!15 = !{!6, !11, i64 44}
!16 = !{!14, !11, i64 0}
!17 = !{!18, !8, i64 8}
!18 = !{!"tag_____IAllocator__", !8, i64 0, !8, i64 8, !8, i64 16, !8, i64 24}
!19 = !{!18, !8, i64 0}
!20 = !{!8, !8, i64 0}
!21 = !{!11, !11, i64 0}
!22 = !{!6, !11, i64 80}
!23 = !{!6, !8, i64 120}
!24 = !{!25, !8, i64 24}
!25 = !{!"tag_____ParenExpression__", !8, i64 0, !26, i64 8, !8, i64 24}
!26 = !{!"", !11, i64 0, !8, i64 8}


; Effective O3 passes: BDCEPass,CorrelatedValuePropagationPass,DSEPass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,InferFunctionAttrsPass,InstCombinePass,JumpThreadingPass,MemCpyOptPass,SROAPass,SimplifyCFGPass,TailCallElimPass