; LLVM IR from caryll/otfcc :: lib/table/otl/subtables/chaining (build)

; 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.__otfcc_ICoverage = type { ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr }
%struct.__otfcc_IClassDef = type { ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr }
%struct.subtable_chaining = type { i32, %union.anon }
%union.anon = type { %struct.anon }
%struct.anon = type { i16, ptr, ptr, ptr, ptr }
%struct.otl_ClassDef = type { i16, i32, i16, ptr, ptr }
%struct.otl_Coverage = type { i16, i32, ptr }
%struct.otl_ChainingRule = type { i16, i16, i16, ptr, i16, ptr }
%struct.otfcc_Handle = type { i32, i16, ptr }
%struct.otl_ChainLookupApplication = type { i16, %struct.otfcc_Handle }

@otl_iCoverage = external constant %struct.__otfcc_ICoverage, align 8
@otl_iClassDef = external constant %struct.__otfcc_IClassDef, 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 willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #0

; Function Attrs: inlinehint nounwind uwtable
declare hidden void @reverseBacktracks(ptr noundef) #1

declare ptr @bk_new_Block(i32 noundef, ...) #2

declare ptr @bk_push(ptr noundef, i32 noundef, ...) #2

declare ptr @bk_newBlockFromBuffer(ptr noundef) #2

declare ptr @bk_build_Block(ptr noundef) #2

; Function Attrs: nounwind uwtable
define dso_local ptr @otfcc_build_chaining_classes(ptr noundef %0) #3 {
  %2 = alloca ptr, align 8
  %3 = alloca ptr, align 8
  %4 = alloca ptr, align 8
  %5 = alloca ptr, align 8
  %6 = alloca ptr, align 8
  %7 = alloca i16, align 2
  %8 = alloca i16, align 2
  %9 = alloca i16, align 2
  %10 = alloca i16, align 2
  %11 = alloca i16, align 2
  %12 = alloca i32, align 4
  %13 = alloca ptr, align 8
  %14 = alloca i16, align 2
  %15 = alloca ptr, align 8
  %16 = alloca i16, align 2
  %17 = alloca i16, align 2
  %18 = alloca i16, align 2
  %19 = alloca i16, align 2
  %20 = alloca i16, align 2
  %21 = alloca ptr, align 8
  %22 = alloca i16, align 2
  %23 = alloca i16, align 2
  %24 = alloca i16, align 2
  %25 = alloca i16, align 2
  store ptr %0, ptr %2, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %3) #5
  %26 = load ptr, ptr %2, align 8, !tbaa !5
  store ptr %26, ptr %3, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %4) #5
  %27 = call ptr @__caryll_allocate_clean(i64 noundef 16, i64 noundef 67)
  store ptr %27, ptr %4, align 8, !tbaa !5
  %28 = load ptr, ptr %3, align 8, !tbaa !5
  %29 = getelementptr inbounds %struct.subtable_chaining, ptr %28, i32 0, i32 1
  %30 = getelementptr inbounds %struct.anon, ptr %29, i32 0, i32 3
  %31 = load ptr, ptr %30, align 8, !tbaa !9
  %32 = getelementptr inbounds %struct.otl_ClassDef, ptr %31, i32 0, i32 0
  %33 = load i16, ptr %32, align 8, !tbaa !10
  %34 = load ptr, ptr %4, align 8, !tbaa !5
  %35 = getelementptr inbounds %struct.otl_Coverage, ptr %34, i32 0, i32 0
  store i16 %33, ptr %35, align 8, !tbaa !14
  %36 = load ptr, ptr %3, align 8, !tbaa !5
  %37 = getelementptr inbounds %struct.subtable_chaining, ptr %36, i32 0, i32 1
  %38 = getelementptr inbounds %struct.anon, ptr %37, i32 0, i32 3
  %39 = load ptr, ptr %38, align 8, !tbaa !9
  %40 = getelementptr inbounds %struct.otl_ClassDef, ptr %39, i32 0, i32 3
  %41 = load ptr, ptr %40, align 8, !tbaa !16
  %42 = load ptr, ptr %4, align 8, !tbaa !5
  %43 = getelementptr inbounds %struct.otl_Coverage, ptr %42, i32 0, i32 2
  store ptr %41, ptr %43, align 8, !tbaa !17
  call void @llvm.lifetime.start.p0(i64 8, ptr %5) #5
  %44 = load ptr, ptr getelementptr inbounds (%struct.__otfcc_ICoverage, ptr @otl_iCoverage, i32 0, i32 12), align 8, !tbaa !18
  %45 = load ptr, ptr %4, align 8, !tbaa !5
  %46 = call ptr %44(ptr noundef %45)
  %47 = call ptr @bk_newBlockFromBuffer(ptr noundef %46)
  %48 = load ptr, ptr getelementptr inbounds (%struct.__otfcc_IClassDef, ptr @otl_iClassDef, i32 0, i32 13), align 8, !tbaa !20
  %49 = load ptr, ptr %3, align 8, !tbaa !5
  %50 = getelementptr inbounds %struct.subtable_chaining, ptr %49, i32 0, i32 1
  %51 = getelementptr inbounds %struct.anon, ptr %50, i32 0, i32 2
  %52 = load ptr, ptr %51, align 8, !tbaa !9
  %53 = call ptr %48(ptr noundef %52)
  %54 = call ptr @bk_newBlockFromBuffer(ptr noundef %53)
  %55 = load ptr, ptr getelementptr inbounds (%struct.__otfcc_IClassDef, ptr @otl_iClassDef, i32 0, i32 13), align 8, !tbaa !20
  %56 = load ptr, ptr %3, align 8, !tbaa !5
  %57 = getelementptr inbounds %struct.subtable_chaining, ptr %56, i32 0, i32 1
  %58 = getelementptr inbounds %struct.anon, ptr %57, i32 0, i32 3
  %59 = load ptr, ptr %58, align 8, !tbaa !9
  %60 = call ptr %55(ptr noundef %59)
  %61 = call ptr @bk_newBlockFromBuffer(ptr noundef %60)
  %62 = load ptr, ptr getelementptr inbounds (%struct.__otfcc_IClassDef, ptr @otl_iClassDef, i32 0, i32 13), align 8, !tbaa !20
  %63 = load ptr, ptr %3, align 8, !tbaa !5
  %64 = getelementptr inbounds %struct.subtable_chaining, ptr %63, i32 0, i32 1
  %65 = getelementptr inbounds %struct.anon, ptr %64, i32 0, i32 4
  %66 = load ptr, ptr %65, align 8, !tbaa !9
  %67 = call ptr %62(ptr noundef %66)
  %68 = call ptr @bk_newBlockFromBuffer(ptr noundef %67)
  %69 = load ptr, ptr %3, align 8, !tbaa !5
  %70 = getelementptr inbounds %struct.subtable_chaining, ptr %69, i32 0, i32 1
  %71 = getelementptr inbounds %struct.anon, ptr %70, i32 0, i32 3
  %72 = load ptr, ptr %71, align 8, !tbaa !9
  %73 = getelementptr inbounds %struct.otl_ClassDef, ptr %72, i32 0, i32 2
  %74 = load i16, ptr %73, align 8, !tbaa !22
  %75 = zext i16 %74 to i32
  %76 = add nsw i32 %75, 1
  %77 = call ptr (i32, ...) @bk_new_Block(i32 noundef 2, i32 noundef 2, i32 noundef 16, ptr noundef %47, i32 noundef 16, ptr noundef %54, i32 noundef 16, ptr noundef %61, i32 noundef 16, ptr noundef %68, i32 noundef 2, i32 noundef %76, i32 noundef 0)
  store ptr %77, ptr %5, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %6) #5
  %78 = load ptr, ptr %3, align 8, !tbaa !5
  %79 = getelementptr inbounds %struct.subtable_chaining, ptr %78, i32 0, i32 1
  %80 = getelementptr inbounds %struct.anon, ptr %79, i32 0, i32 3
  %81 = load ptr, ptr %80, align 8, !tbaa !9
  %82 = getelementptr inbounds %struct.otl_ClassDef, ptr %81, i32 0, i32 2
  %83 = load i16, ptr %82, align 8, !tbaa !22
  %84 = zext i16 %83 to i32
  %85 = add nsw i32 %84, 1
  %86 = sext i32 %85 to i64
  %87 = mul i64 2, %86
  %88 = call ptr @__caryll_allocate_clean(i64 noundef %87, i64 noundef 81)
  store ptr %88, ptr %6, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 2, ptr %7) #5
  store i16 0, ptr %7, align 2, !tbaa !23
  br label %89

89:                                               ; preds = %106, %1
  %90 = load i16, ptr %7, align 2, !tbaa !23
  %91 = zext i16 %90 to i32
  %92 = load ptr, ptr %3, align 8, !tbaa !5
  %93 = getelementptr inbounds %struct.subtable_chaining, ptr %92, i32 0, i32 1
  %94 = getelementptr inbounds %struct.anon, ptr %93, i32 0, i32 3
  %95 = load ptr, ptr %94, align 8, !tbaa !9
  %96 = getelementptr inbounds %struct.otl_ClassDef, ptr %95, i32 0, i32 2
  %97 = load i16, ptr %96, align 8, !tbaa !22
  %98 = zext i16 %97 to i32
  %99 = icmp sle i32 %91, %98
  br i1 %99, label %101, label %100

100:                                              ; preds = %89
  call void @llvm.lifetime.end.p0(i64 2, ptr %7) #5
  br label %109

101:                                              ; preds = %89
  %102 = load ptr, ptr %6, align 8, !tbaa !5
  %103 = load i16, ptr %7, align 2, !tbaa !23
  %104 = zext i16 %103 to i64
  %105 = getelementptr inbounds i16, ptr %102, i64 %104
  store i16 0, ptr %105, align 2, !tbaa !23
  br label %106

106:                                              ; preds = %101
  %107 = load i16, ptr %7, align 2, !tbaa !23
  %108 = add i16 %107, 1
  store i16 %108, ptr %7, align 2, !tbaa !23
  br label %89, !llvm.loop !24

109:                                              ; preds = %100
  call void @llvm.lifetime.start.p0(i64 2, ptr %8) #5
  store i16 0, ptr %8, align 2, !tbaa !23
  br label %110

110:                                              ; preds = %170, %109
  %111 = load i16, ptr %8, align 2, !tbaa !23
  %112 = zext i16 %111 to i32
  %113 = load ptr, ptr %3, align 8, !tbaa !5
  %114 = getelementptr inbounds %struct.subtable_chaining, ptr %113, i32 0, i32 1
  %115 = getelementptr inbounds %struct.anon, ptr %114, i32 0, i32 0
  %116 = load i16, ptr %115, align 8, !tbaa !9
  %117 = zext i16 %116 to i32
  %118 = icmp slt i32 %112, %117
  br i1 %118, label %120, label %119

119:                                              ; preds = %110
  call void @llvm.lifetime.end.p0(i64 2, ptr %8) #5
  br label %173

120:                                              ; preds = %110
  call void @llvm.lifetime.start.p0(i64 2, ptr %9) #5
  %121 = load ptr, ptr %3, align 8, !tbaa !5
  %122 = getelementptr inbounds %struct.subtable_chaining, ptr %121, i32 0, i32 1
  %123 = getelementptr inbounds %struct.anon, ptr %122, i32 0, i32 1
  %124 = load ptr, ptr %123, align 8, !tbaa !9
  %125 = load i16, ptr %8, align 2, !tbaa !23
  %126 = zext i16 %125 to i64
  %127 = getelementptr inbounds ptr, ptr %124, i64 %126
  %128 = load ptr, ptr %127, align 8, !tbaa !5
  %129 = getelementptr inbounds %struct.otl_ChainingRule, ptr %128, i32 0, i32 1
  %130 = load i16, ptr %129, align 2, !tbaa !26
  store i16 %130, ptr %9, align 2, !tbaa !23
  call void @llvm.lifetime.start.p0(i64 2, ptr %10) #5
  %131 = load ptr, ptr %3, align 8, !tbaa !5
  %132 = getelementptr inbounds %struct.subtable_chaining, ptr %131, i32 0, i32 1
  %133 = getelementptr inbounds %struct.anon, ptr %132, i32 0, i32 1
  %134 = load ptr, ptr %133, align 8, !tbaa !9
  %135 = load i16, ptr %8, align 2, !tbaa !23
  %136 = zext i16 %135 to i64
  %137 = getelementptr inbounds ptr, ptr %134, i64 %136
  %138 = load ptr, ptr %137, align 8, !tbaa !5
  %139 = getelementptr inbounds %struct.otl_ChainingRule, ptr %138, i32 0, i32 3
  %140 = load ptr, ptr %139, align 8, !tbaa !28
  %141 = load i16, ptr %9, align 2, !tbaa !23
  %142 = zext i16 %141 to i64
  %143 = getelementptr inbounds ptr, ptr %140, i64 %142
  %144 = load ptr, ptr %143, align 8, !tbaa !5
  %145 = getelementptr inbounds %struct.otl_Coverage, ptr %144, i32 0, i32 2
  %146 = load ptr, ptr %145, align 8, !tbaa !17
  %147 = getelementptr inbounds %struct.otfcc_Handle, ptr %146, i64 0
  %148 = getelementptr inbounds %struct.otfcc_Handle, ptr %147, i32 0, i32 1
  %149 = load i16, ptr %148, align 4, !tbaa !29
  store i16 %149, ptr %10, align 2, !tbaa !23
  %150 = load i16, ptr %10, align 2, !tbaa !23
  %151 = zext i16 %150 to i32
  %152 = load ptr, ptr %3, align 8, !tbaa !5
  %153 = getelementptr inbounds %struct.subtable_chaining, ptr %152, i32 0, i32 1
  %154 = getelementptr inbounds %struct.anon, ptr %153, i32 0, i32 3
  %155 = load ptr, ptr %154, align 8, !tbaa !9
  %156 = getelementptr inbounds %struct.otl_ClassDef, ptr %155, i32 0, i32 2
  %157 = load i16, ptr %156, align 8, !tbaa !22
  %158 = zext i16 %157 to i32
  %159 = icmp sle i32 %151, %158
  br i1 %159, label %160, label %169

160:                                              ; preds = %120
  %161 = load ptr, ptr %6, align 8, !tbaa !5
  %162 = load i16, ptr %10, align 2, !tbaa !23
  %163 = zext i16 %162 to i64
  %164 = getelementptr inbounds i16, ptr %161, i64 %163
  %165 = load i16, ptr %164, align 2, !tbaa !23
  %166 = zext i16 %165 to i32
  %167 = add nsw i32 %166, 1
  %168 = trunc i32 %167 to i16
  store i16 %168, ptr %164, align 2, !tbaa !23
  br label %169

169:                                              ; preds = %160, %120
  call void @llvm.lifetime.end.p0(i64 2, ptr %10) #5
  call void @llvm.lifetime.end.p0(i64 2, ptr %9) #5
  br label %170

170:                                              ; preds = %169
  %171 = load i16, ptr %8, align 2, !tbaa !23
  %172 = add i16 %171, 1
  store i16 %172, ptr %8, align 2, !tbaa !23
  br label %110, !llvm.loop !31

173:                                              ; preds = %119
  call void @llvm.lifetime.start.p0(i64 2, ptr %11) #5
  store i16 0, ptr %11, align 2, !tbaa !23
  br label %174

174:                                              ; preds = %434, %173
  %175 = load i16, ptr %11, align 2, !tbaa !23
  %176 = zext i16 %175 to i32
  %177 = load ptr, ptr %3, align 8, !tbaa !5
  %178 = getelementptr inbounds %struct.subtable_chaining, ptr %177, i32 0, i32 1
  %179 = getelementptr inbounds %struct.anon, ptr %178, i32 0, i32 3
  %180 = load ptr, ptr %179, align 8, !tbaa !9
  %181 = getelementptr inbounds %struct.otl_ClassDef, ptr %180, i32 0, i32 2
  %182 = load i16, ptr %181, align 8, !tbaa !22
  %183 = zext i16 %182 to i32
  %184 = icmp sle i32 %176, %183
  br i1 %184, label %186, label %185

185:                                              ; preds = %174
  store i32 8, ptr %12, align 4
  call void @llvm.lifetime.end.p0(i64 2, ptr %11) #5
  br label %437

186:                                              ; preds = %174
  %187 = load ptr, ptr %6, align 8, !tbaa !5
  %188 = load i16, ptr %11, align 2, !tbaa !23
  %189 = zext i16 %188 to i64
  %190 = getelementptr inbounds i16, ptr %187, i64 %189
  %191 = load i16, ptr %190, align 2, !tbaa !23
  %192 = icmp ne i16 %191, 0
  br i1 %192, label %193, label %430

193:                                              ; preds = %186
  call void @llvm.lifetime.start.p0(i64 8, ptr %13) #5
  %194 = load ptr, ptr %6, align 8, !tbaa !5
  %195 = load i16, ptr %11, align 2, !tbaa !23
  %196 = zext i16 %195 to i64
  %197 = getelementptr inbounds i16, ptr %194, i64 %196
  %198 = load i16, ptr %197, align 2, !tbaa !23
  %199 = zext i16 %198 to i32
  %200 = call ptr (i32, ...) @bk_new_Block(i32 noundef 2, i32 noundef %199, i32 noundef 0)
  store ptr %200, ptr %13, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 2, ptr %14) #5
  store i16 0, ptr %14, align 2, !tbaa !23
  br label %201

201:                                              ; preds = %423, %193
  %202 = load i16, ptr %14, align 2, !tbaa !23
  %203 = zext i16 %202 to i32
  %204 = load ptr, ptr %3, align 8, !tbaa !5
  %205 = getelementptr inbounds %struct.subtable_chaining, ptr %204, i32 0, i32 1
  %206 = getelementptr inbounds %struct.anon, ptr %205, i32 0, i32 0
  %207 = load i16, ptr %206, align 8, !tbaa !9
  %208 = zext i16 %207 to i32
  %209 = icmp slt i32 %203, %208
  br i1 %209, label %211, label %210

210:                                              ; preds = %201
  store i32 11, ptr %12, align 4
  call void @llvm.lifetime.end.p0(i64 2, ptr %14) #5
  br label %426

211:                                              ; preds = %201
  call void @llvm.lifetime.start.p0(i64 8, ptr %15) #5
  %212 = load ptr, ptr %3, align 8, !tbaa !5
  %213 = getelementptr inbounds %struct.subtable_chaining, ptr %212, i32 0, i32 1
  %214 = getelementptr inbounds %struct.anon, ptr %213, i32 0, i32 1
  %215 = load ptr, ptr %214, align 8, !tbaa !9
  %216 = load i16, ptr %14, align 2, !tbaa !23
  %217 = zext i16 %216 to i64
  %218 = getelementptr inbounds ptr, ptr %215, i64 %217
  %219 = load ptr, ptr %218, align 8, !tbaa !5
  store ptr %219, ptr %15, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 2, ptr %16) #5
  %220 = load ptr, ptr %15, align 8, !tbaa !5
  %221 = getelementptr inbounds %struct.otl_ChainingRule, ptr %220, i32 0, i32 3
  %222 = load ptr, ptr %221, align 8, !tbaa !28
  %223 = load ptr, ptr %15, align 8, !tbaa !5
  %224 = getelementptr inbounds %struct.otl_ChainingRule, ptr %223, i32 0, i32 1
  %225 = load i16, ptr %224, align 2, !tbaa !26
  %226 = zext i16 %225 to i64
  %227 = getelementptr inbounds ptr, ptr %222, i64 %226
  %228 = load ptr, ptr %227, align 8, !tbaa !5
  %229 = getelementptr inbounds %struct.otl_Coverage, ptr %228, i32 0, i32 2
  %230 = load ptr, ptr %229, align 8, !tbaa !17
  %231 = getelementptr inbounds %struct.otfcc_Handle, ptr %230, i64 0
  %232 = getelementptr inbounds %struct.otfcc_Handle, ptr %231, i32 0, i32 1
  %233 = load i16, ptr %232, align 4, !tbaa !29
  store i16 %233, ptr %16, align 2, !tbaa !23
  %234 = load i16, ptr %16, align 2, !tbaa !23
  %235 = zext i16 %234 to i32
  %236 = load i16, ptr %11, align 2, !tbaa !23
  %237 = zext i16 %236 to i32
  %238 = icmp ne i32 %235, %237
  br i1 %238, label %239, label %240

239:                                              ; preds = %211
  store i32 13, ptr %12, align 4
  br label %420

240:                                              ; preds = %211
  %241 = load ptr, ptr %15, align 8, !tbaa !5
  call void @reverseBacktracks(ptr noundef %241)
  call void @llvm.lifetime.start.p0(i64 2, ptr %17) #5
  %242 = load ptr, ptr %15, align 8, !tbaa !5
  %243 = getelementptr inbounds %struct.otl_ChainingRule, ptr %242, i32 0, i32 1
  %244 = load i16, ptr %243, align 2, !tbaa !26
  store i16 %244, ptr %17, align 2, !tbaa !23
  call void @llvm.lifetime.start.p0(i64 2, ptr %18) #5
  %245 = load ptr, ptr %15, align 8, !tbaa !5
  %246 = getelementptr inbounds %struct.otl_ChainingRule, ptr %245, i32 0, i32 2
  %247 = load i16, ptr %246, align 4, !tbaa !32
  %248 = zext i16 %247 to i32
  %249 = load ptr, ptr %15, align 8, !tbaa !5
  %250 = getelementptr inbounds %struct.otl_ChainingRule, ptr %249, i32 0, i32 1
  %251 = load i16, ptr %250, align 2, !tbaa !26
  %252 = zext i16 %251 to i32
  %253 = sub nsw i32 %248, %252
  %254 = trunc i32 %253 to i16
  store i16 %254, ptr %18, align 2, !tbaa !23
  call void @llvm.lifetime.start.p0(i64 2, ptr %19) #5
  %255 = load ptr, ptr %15, align 8, !tbaa !5
  %256 = getelementptr inbounds %struct.otl_ChainingRule, ptr %255, i32 0, i32 0
  %257 = load i16, ptr %256, align 8, !tbaa !33
  %258 = zext i16 %257 to i32
  %259 = load ptr, ptr %15, align 8, !tbaa !5
  %260 = getelementptr inbounds %struct.otl_ChainingRule, ptr %259, i32 0, i32 2
  %261 = load i16, ptr %260, align 4, !tbaa !32
  %262 = zext i16 %261 to i32
  %263 = sub nsw i32 %258, %262
  %264 = trunc i32 %263 to i16
  store i16 %264, ptr %19, align 2, !tbaa !23
  call void @llvm.lifetime.start.p0(i64 2, ptr %20) #5
  %265 = load ptr, ptr %15, align 8, !tbaa !5
  %266 = getelementptr inbounds %struct.otl_ChainingRule, ptr %265, i32 0, i32 4
  %267 = load i16, ptr %266, align 8, !tbaa !34
  store i16 %267, ptr %20, align 2, !tbaa !23
  call void @llvm.lifetime.start.p0(i64 8, ptr %21) #5
  %268 = call ptr (i32, ...) @bk_new_Block(i32 noundef 0)
  store ptr %268, ptr %21, align 8, !tbaa !5
  %269 = load ptr, ptr %21, align 8, !tbaa !5
  %270 = load i16, ptr %17, align 2, !tbaa !23
  %271 = zext i16 %270 to i32
  %272 = call ptr (ptr, i32, ...) @bk_push(ptr noundef %269, i32 noundef 2, i32 noundef %271, i32 noundef 0)
  call void @llvm.lifetime.start.p0(i64 2, ptr %22) #5
  store i16 0, ptr %22, align 2, !tbaa !23
  br label %273

273:                                              ; preds = %298, %240
  %274 = load i16, ptr %22, align 2, !tbaa !23
  %275 = zext i16 %274 to i32
  %276 = load ptr, ptr %15, align 8, !tbaa !5
  %277 = getelementptr inbounds %struct.otl_ChainingRule, ptr %276, i32 0, i32 1
  %278 = load i16, ptr %277, align 2, !tbaa !26
  %279 = zext i16 %278 to i32
  %280 = icmp slt i32 %275, %279
  br i1 %280, label %282, label %281

281:                                              ; preds = %273
  store i32 14, ptr %12, align 4
  call void @llvm.lifetime.end.p0(i64 2, ptr %22) #5
  br label %301

282:                                              ; preds = %273
  %283 = load ptr, ptr %21, align 8, !tbaa !5
  %284 = load ptr, ptr %15, align 8, !tbaa !5
  %285 = getelementptr inbounds %struct.otl_ChainingRule, ptr %284, i32 0, i32 3
  %286 = load ptr, ptr %285, align 8, !tbaa !28
  %287 = load i16, ptr %22, align 2, !tbaa !23
  %288 = zext i16 %287 to i64
  %289 = getelementptr inbounds ptr, ptr %286, i64 %288
  %290 = load ptr, ptr %289, align 8, !tbaa !5
  %291 = getelementptr inbounds %struct.otl_Coverage, ptr %290, i32 0, i32 2
  %292 = load ptr, ptr %291, align 8, !tbaa !17
  %293 = getelementptr inbounds %struct.otfcc_Handle, ptr %292, i64 0
  %294 = getelementptr inbounds %struct.otfcc_Handle, ptr %293, i32 0, i32 1
  %295 = load i16, ptr %294, align 4, !tbaa !29
  %296 = zext i16 %295 to i32
  %297 = call ptr (ptr, i32, ...) @bk_push(ptr noundef %283, i32 noundef 2, i32 noundef %296, i32 noundef 0)
  br label %298

298:                                              ; preds = %282
  %299 = load i16, ptr %22, align 2, !tbaa !23
  %300 = add i16 %299, 1
  store i16 %300, ptr %22, align 2, !tbaa !23
  br label %273, !llvm.loop !35

301:                                              ; preds = %281
  %302 = load ptr, ptr %21, align 8, !tbaa !5
  %303 = load i16, ptr %18, align 2, !tbaa !23
  %304 = zext i16 %303 to i32
  %305 = call ptr (ptr, i32, ...) @bk_push(ptr noundef %302, i32 noundef 2, i32 noundef %304, i32 noundef 0)
  call void @llvm.lifetime.start.p0(i64 2, ptr %23) #5
  %306 = load ptr, ptr %15, align 8, !tbaa !5
  %307 = getelementptr inbounds %struct.otl_ChainingRule, ptr %306, i32 0, i32 1
  %308 = load i16, ptr %307, align 2, !tbaa !26
  %309 = zext i16 %308 to i32
  %310 = add nsw i32 %309, 1
  %311 = trunc i32 %310 to i16
  store i16 %311, ptr %23, align 2, !tbaa !23
  br label %312

312:                                              ; preds = %337, %301
  %313 = load i16, ptr %23, align 2, !tbaa !23
  %314 = zext i16 %313 to i32
  %315 = load ptr, ptr %15, align 8, !tbaa !5
  %316 = getelementptr inbounds %struct.otl_ChainingRule, ptr %315, i32 0, i32 2
  %317 = load i16, ptr %316, align 4, !tbaa !32
  %318 = zext i16 %317 to i32
  %319 = icmp slt i32 %314, %318
  br i1 %319, label %321, label %320

320:                                              ; preds = %312
  store i32 17, ptr %12, align 4
  call void @llvm.lifetime.end.p0(i64 2, ptr %23) #5
  br label %340

321:                                              ; preds = %312
  %322 = load ptr, ptr %21, align 8, !tbaa !5
  %323 = load ptr, ptr %15, align 8, !tbaa !5
  %324 = getelementptr inbounds %struct.otl_ChainingRule, ptr %323, i32 0, i32 3
  %325 = load ptr, ptr %324, align 8, !tbaa !28
  %326 = load i16, ptr %23, align 2, !tbaa !23
  %327 = zext i16 %326 to i64
  %328 = getelementptr inbounds ptr, ptr %325, i64 %327
  %329 = load ptr, ptr %328, align 8, !tbaa !5
  %330 = getelementptr inbounds %struct.otl_Coverage, ptr %329, i32 0, i32 2
  %331 = load ptr, ptr %330, align 8, !tbaa !17
  %332 = getelementptr inbounds %struct.otfcc_Handle, ptr %331, i64 0
  %333 = getelementptr inbounds %struct.otfcc_Handle, ptr %332, i32 0, i32 1
  %334 = load i16, ptr %333, align 4, !tbaa !29
  %335 = zext i16 %334 to i32
  %336 = call ptr (ptr, i32, ...) @bk_push(ptr noundef %322, i32 noundef 2, i32 noundef %335, i32 noundef 0)
  br label %337

337:                                              ; preds = %321
  %338 = load i16, ptr %23, align 2, !tbaa !23
  %339 = add i16 %338, 1
  store i16 %339, ptr %23, align 2, !tbaa !23
  br label %312, !llvm.loop !36

340:                                              ; preds = %320
  %341 = load ptr, ptr %21, align 8, !tbaa !5
  %342 = load i16, ptr %19, align 2, !tbaa !23
  %343 = zext i16 %342 to i32
  %344 = call ptr (ptr, i32, ...) @bk_push(ptr noundef %341, i32 noundef 2, i32 noundef %343, i32 noundef 0)
  call void @llvm.lifetime.start.p0(i64 2, ptr %24) #5
  %345 = load ptr, ptr %15, align 8, !tbaa !5
  %346 = getelementptr inbounds %struct.otl_ChainingRule, ptr %345, i32 0, i32 2
  %347 = load i16, ptr %346, align 4, !tbaa !32
  store i16 %347, ptr %24, align 2, !tbaa !23
  br label %348

348:                                              ; preds = %373, %340
  %349 = load i16, ptr %24, align 2, !tbaa !23
  %350 = zext i16 %349 to i32
  %351 = load ptr, ptr %15, align 8, !tbaa !5
  %352 = getelementptr inbounds %struct.otl_ChainingRule, ptr %351, i32 0, i32 0
  %353 = load i16, ptr %352, align 8, !tbaa !33
  %354 = zext i16 %353 to i32
  %355 = icmp slt i32 %350, %354
  br i1 %355, label %357, label %356

356:                                              ; preds = %348
  store i32 20, ptr %12, align 4
  call void @llvm.lifetime.end.p0(i64 2, ptr %24) #5
  br label %376

357:                                              ; preds = %348
  %358 = load ptr, ptr %21, align 8, !tbaa !5
  %359 = load ptr, ptr %15, align 8, !tbaa !5
  %360 = getelementptr inbounds %struct.otl_ChainingRule, ptr %359, i32 0, i32 3
  %361 = load ptr, ptr %360, align 8, !tbaa !28
  %362 = load i16, ptr %24, align 2, !tbaa !23
  %363 = zext i16 %362 to i64
  %364 = getelementptr inbounds ptr, ptr %361, i64 %363
  %365 = load ptr, ptr %364, align 8, !tbaa !5
  %366 = getelementptr inbounds %struct.otl_Coverage, ptr %365, i32 0, i32 2
  %367 = load ptr, ptr %366, align 8, !tbaa !17
  %368 = getelementptr inbounds %struct.otfcc_Handle, ptr %367, i64 0
  %369 = getelementptr inbounds %struct.otfcc_Handle, ptr %368, i32 0, i32 1
  %370 = load i16, ptr %369, align 4, !tbaa !29
  %371 = zext i16 %370 to i32
  %372 = call ptr (ptr, i32, ...) @bk_push(ptr noundef %358, i32 noundef 2, i32 noundef %371, i32 noundef 0)
  br label %373

373:                                              ; preds = %357
  %374 = load i16, ptr %24, align 2, !tbaa !23
  %375 = add i16 %374, 1
  store i16 %375, ptr %24, align 2, !tbaa !23
  br label %348, !llvm.loop !37

376:                                              ; preds = %356
  %377 = load ptr, ptr %21, align 8, !tbaa !5
  %378 = load i16, ptr %20, align 2, !tbaa !23
  %379 = zext i16 %378 to i32
  %380 = call ptr (ptr, i32, ...) @bk_push(ptr noundef %377, i32 noundef 2, i32 noundef %379, i32 noundef 0)
  call void @llvm.lifetime.start.p0(i64 2, ptr %25) #5
  store i16 0, ptr %25, align 2, !tbaa !23
  br label %381

381:                                              ; preds = %413, %376
  %382 = load i16, ptr %25, align 2, !tbaa !23
  %383 = zext i16 %382 to i32
  %384 = load i16, ptr %20, align 2, !tbaa !23
  %385 = zext i16 %384 to i32
  %386 = icmp slt i32 %383, %385
  br i1 %386, label %388, label %387

387:                                              ; preds = %381
  store i32 23, ptr %12, align 4
  call void @llvm.lifetime.end.p0(i64 2, ptr %25) #5
  br label %416

388:                                              ; preds = %381
  %389 = load ptr, ptr %21, align 8, !tbaa !5
  %390 = load ptr, ptr %15, align 8, !tbaa !5
  %391 = getelementptr inbounds %struct.otl_ChainingRule, ptr %390, i32 0, i32 5
  %392 = load ptr, ptr %391, align 8, !tbaa !38
  %393 = load i16, ptr %25, align 2, !tbaa !23
  %394 = zext i16 %393 to i64
  %395 = getelementptr inbounds %struct.otl_ChainLookupApplication, ptr %392, i64 %394
  %396 = getelementptr inbounds %struct.otl_ChainLookupApplication, ptr %395, i32 0, i32 0
  %397 = load i16, ptr %396, align 8, !tbaa !39
  %398 = zext i16 %397 to i32
  %399 = load i16, ptr %17, align 2, !tbaa !23
  %400 = zext i16 %399 to i32
  %401 = sub nsw i32 %398, %400
  %402 = load ptr, ptr %15, align 8, !tbaa !5
  %403 = getelementptr inbounds %struct.otl_ChainingRule, ptr %402, i32 0, i32 5
  %404 = load ptr, ptr %403, align 8, !tbaa !38
  %405 = load i16, ptr %25, align 2, !tbaa !23
  %406 = zext i16 %405 to i64
  %407 = getelementptr inbounds %struct.otl_ChainLookupApplication, ptr %404, i64 %406
  %408 = getelementptr inbounds %struct.otl_ChainLookupApplication, ptr %407, i32 0, i32 1
  %409 = getelementptr inbounds %struct.otfcc_Handle, ptr %408, i32 0, i32 1
  %410 = load i16, ptr %409, align 4, !tbaa !41
  %411 = zext i16 %410 to i32
  %412 = call ptr (ptr, i32, ...) @bk_push(ptr noundef %389, i32 noundef 2, i32 noundef %401, i32 noundef 2, i32 noundef %411, i32 noundef 0)
  br label %413

413:                                              ; preds = %388
  %414 = load i16, ptr %25, align 2, !tbaa !23
  %415 = add i16 %414, 1
  store i16 %415, ptr %25, align 2, !tbaa !23
  br label %381, !llvm.loop !42

416:                                              ; preds = %387
  %417 = load ptr, ptr %13, align 8, !tbaa !5
  %418 = load ptr, ptr %21, align 8, !tbaa !5
  %419 = call ptr (ptr, i32, ...) @bk_push(ptr noundef %417, i32 noundef 16, ptr noundef %418, i32 noundef 0)
  call void @llvm.lifetime.end.p0(i64 8, ptr %21) #5
  call void @llvm.lifetime.end.p0(i64 2, ptr %20) #5
  call void @llvm.lifetime.end.p0(i64 2, ptr %19) #5
  call void @llvm.lifetime.end.p0(i64 2, ptr %18) #5
  call void @llvm.lifetime.end.p0(i64 2, ptr %17) #5
  store i32 0, ptr %12, align 4
  br label %420

420:                                              ; preds = %416, %239
  call void @llvm.lifetime.end.p0(i64 2, ptr %16) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %15) #5
  %421 = load i32, ptr %12, align 4
  switch i32 %421, label %442 [
    i32 0, label %422
    i32 13, label %423
  ]

422:                                              ; preds = %420
  br label %423

423:                                              ; preds = %422, %420
  %424 = load i16, ptr %14, align 2, !tbaa !23
  %425 = add i16 %424, 1
  store i16 %425, ptr %14, align 2, !tbaa !23
  br label %201, !llvm.loop !43

426:                                              ; preds = %210
  %427 = load ptr, ptr %5, align 8, !tbaa !5
  %428 = load ptr, ptr %13, align 8, !tbaa !5
  %429 = call ptr (ptr, i32, ...) @bk_push(ptr noundef %427, i32 noundef 16, ptr noundef %428, i32 noundef 0)
  call void @llvm.lifetime.end.p0(i64 8, ptr %13) #5
  br label %433

430:                                              ; preds = %186
  %431 = load ptr, ptr %5, align 8, !tbaa !5
  %432 = call ptr (ptr, i32, ...) @bk_push(ptr noundef %431, i32 noundef 16, ptr noundef null, i32 noundef 0)
  br label %433

433:                                              ; preds = %430, %426
  br label %434

434:                                              ; preds = %433
  %435 = load i16, ptr %11, align 2, !tbaa !23
  %436 = add i16 %435, 1
  store i16 %436, ptr %11, align 2, !tbaa !23
  br label %174, !llvm.loop !44

437:                                              ; preds = %185
  %438 = load ptr, ptr %4, align 8, !tbaa !5
  call void @free(ptr noundef %438) #5
  store ptr null, ptr %4, align 8, !tbaa !5
  %439 = load ptr, ptr %6, align 8, !tbaa !5
  call void @free(ptr noundef %439) #5
  store ptr null, ptr %6, align 8, !tbaa !5
  %440 = load ptr, ptr %5, align 8, !tbaa !5
  %441 = call ptr @bk_build_Block(ptr noundef %440)
  store i32 1, ptr %12, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %6) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %5) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %4) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %3) #5
  ret ptr %441

442:                                              ; preds = %420
  unreachable
}

; Function Attrs: inlinehint nounwind uwtable
declare hidden ptr @__caryll_allocate_clean(i64 noundef, i64 noundef) #1

; Function Attrs: nounwind
declare void @free(ptr noundef) #4

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { inlinehint 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 #2 = { "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 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 #4 = { nounwind "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, !12, i64 0}
!11 = !{!"", !12, i64 0, !13, i64 4, !12, i64 8, !6, i64 16, !6, i64 24}
!12 = !{!"short", !7, i64 0}
!13 = !{!"int", !7, i64 0}
!14 = !{!15, !12, i64 0}
!15 = !{!"", !12, i64 0, !13, i64 4, !6, i64 8}
!16 = !{!11, !6, i64 16}
!17 = !{!15, !6, i64 8}
!18 = !{!19, !6, i64 96}
!19 = !{!"__otfcc_ICoverage", !6, i64 0, !6, i64 8, !6, i64 16, !6, i64 24, !6, i64 32, !6, i64 40, !6, i64 48, !6, i64 56, !6, i64 64, !6, i64 72, !6, i64 80, !6, i64 88, !6, i64 96, !6, i64 104, !6, i64 112, !6, i64 120}
!20 = !{!21, !6, i64 104}
!21 = !{!"__otfcc_IClassDef", !6, i64 0, !6, i64 8, !6, i64 16, !6, i64 24, !6, i64 32, !6, i64 40, !6, i64 48, !6, i64 56, !6, i64 64, !6, i64 72, !6, i64 80, !6, i64 88, !6, i64 96, !6, i64 104, !6, i64 112}
!22 = !{!11, !12, i64 8}
!23 = !{!12, !12, i64 0}
!24 = distinct !{!24, !25}
!25 = !{!"llvm.loop.mustprogress"}
!26 = !{!27, !12, i64 2}
!27 = !{!"", !12, i64 0, !12, i64 2, !12, i64 4, !6, i64 8, !12, i64 16, !6, i64 24}
!28 = !{!27, !6, i64 8}
!29 = !{!30, !12, i64 4}
!30 = !{!"otfcc_Handle", !13, i64 0, !12, i64 4, !6, i64 8}
!31 = distinct !{!31, !25}
!32 = !{!27, !12, i64 4}
!33 = !{!27, !12, i64 0}
!34 = !{!27, !12, i64 16}
!35 = distinct !{!35, !25}
!36 = distinct !{!36, !25}
!37 = distinct !{!37, !25}
!38 = !{!27, !6, i64 24}
!39 = !{!40, !12, i64 0}
!40 = !{!"", !12, i64 0, !30, i64 8}
!41 = !{!40, !12, i64 12}
!42 = distinct !{!42, !25}
!43 = distinct !{!43, !25}
!44 = distinct !{!44, !25}


; 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.__otfcc_ICoverage = type { ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr }
%struct.__otfcc_IClassDef = type { ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr }
%struct.otl_ChainLookupApplication = type { i16, %struct.otfcc_Handle }
%struct.otfcc_Handle = type { i32, i16, ptr }

@otl_iCoverage = external local_unnamed_addr constant %struct.__otfcc_ICoverage, align 8
@otl_iClassDef = external local_unnamed_addr constant %struct.__otfcc_IClassDef, align 8

; Function Attrs: inlinehint nounwind uwtable
declare hidden void @reverseBacktracks(ptr noundef) local_unnamed_addr #0

declare ptr @bk_new_Block(i32 noundef, ...) local_unnamed_addr #1

declare ptr @bk_push(ptr noundef, i32 noundef, ...) local_unnamed_addr #1

declare ptr @bk_newBlockFromBuffer(ptr noundef) local_unnamed_addr #1

declare ptr @bk_build_Block(ptr noundef) local_unnamed_addr #1

; Function Attrs: nounwind uwtable
define dso_local ptr @otfcc_build_chaining_classes(ptr nocapture noundef readonly %0) local_unnamed_addr #2 {
  %2 = tail call ptr @__caryll_allocate_clean(i64 noundef 16, i64 noundef 67)
  %3 = getelementptr inbounds i8, ptr %0, i64 32
  %4 = load ptr, ptr %3, align 8, !tbaa !5
  %5 = load i16, ptr %4, align 8, !tbaa !8
  store i16 %5, ptr %2, align 8, !tbaa !13
  %6 = load ptr, ptr %3, align 8, !tbaa !5
  %7 = getelementptr inbounds i8, ptr %6, i64 16
  %8 = load ptr, ptr %7, align 8, !tbaa !15
  %9 = getelementptr inbounds i8, ptr %2, i64 8
  store ptr %8, ptr %9, align 8, !tbaa !16
  %10 = load ptr, ptr getelementptr inbounds (i8, ptr @otl_iCoverage, i64 96), align 8, !tbaa !17
  %11 = tail call ptr %10(ptr noundef nonnull %2) #4
  %12 = tail call ptr @bk_newBlockFromBuffer(ptr noundef %11) #4
  %13 = load ptr, ptr getelementptr inbounds (i8, ptr @otl_iClassDef, i64 104), align 8, !tbaa !19
  %14 = getelementptr inbounds i8, ptr %0, i64 24
  %15 = load ptr, ptr %14, align 8, !tbaa !5
  %16 = tail call ptr %13(ptr noundef %15) #4
  %17 = tail call ptr @bk_newBlockFromBuffer(ptr noundef %16) #4
  %18 = load ptr, ptr %3, align 8, !tbaa !5
  %19 = tail call ptr %13(ptr noundef %18) #4
  %20 = tail call ptr @bk_newBlockFromBuffer(ptr noundef %19) #4
  %21 = getelementptr inbounds i8, ptr %0, i64 40
  %22 = load ptr, ptr %21, align 8, !tbaa !5
  %23 = tail call ptr %13(ptr noundef %22) #4
  %24 = tail call ptr @bk_newBlockFromBuffer(ptr noundef %23) #4
  %25 = load ptr, ptr %3, align 8, !tbaa !5
  %26 = getelementptr inbounds i8, ptr %25, i64 8
  %27 = load i16, ptr %26, align 8, !tbaa !21
  %28 = zext i16 %27 to i32
  %29 = add nuw nsw i32 %28, 1
  %30 = tail call ptr (i32, ...) @bk_new_Block(i32 noundef 2, i32 noundef 2, i32 noundef 16, ptr noundef %12, i32 noundef 16, ptr noundef %17, i32 noundef 16, ptr noundef %20, i32 noundef 16, ptr noundef %24, i32 noundef 2, i32 noundef %29, i32 noundef 0) #4
  %31 = load ptr, ptr %3, align 8, !tbaa !5
  %32 = getelementptr inbounds i8, ptr %31, i64 8
  %33 = load i16, ptr %32, align 8, !tbaa !21
  %34 = zext i16 %33 to i64
  %35 = shl nuw nsw i64 %34, 1
  %36 = add nuw nsw i64 %35, 2
  %37 = tail call ptr @__caryll_allocate_clean(i64 noundef %36, i64 noundef 81)
  br label %41

.preheader108:                                    ; preds = %41
  %38 = getelementptr inbounds i8, ptr %0, i64 8
  %39 = load i16, ptr %38, align 8, !tbaa !5
  %.not132 = icmp eq i16 %39, 0
  br i1 %.not132, label %.preheader, label %.lr.ph

.lr.ph:                                           ; preds = %.preheader108
  %40 = getelementptr inbounds i8, ptr %0, i64 16
  br label %49

41:                                               ; preds = %1, %41
  %.098109 = phi i16 [ 0, %1 ], [ %44, %41 ]
  %42 = zext i16 %.098109 to i64
  %43 = getelementptr inbounds i16, ptr %37, i64 %42
  store i16 0, ptr %43, align 2, !tbaa !22
  %44 = add i16 %.098109, 1
  %45 = load ptr, ptr %3, align 8, !tbaa !5
  %46 = getelementptr inbounds i8, ptr %45, i64 8
  %47 = load i16, ptr %46, align 8, !tbaa !21
  %.not = icmp ugt i16 %44, %47
  br i1 %.not, label %.preheader108, label %41, !llvm.loop !23

.preheader:                                       ; preds = %73, %.preheader108
  %48 = getelementptr inbounds i8, ptr %0, i64 16
  br label %79

49:                                               ; preds = %.lr.ph, %73
  %50 = phi i16 [ %39, %.lr.ph ], [ %74, %73 ]
  %indvars.iv = phi i64 [ 0, %.lr.ph ], [ %indvars.iv.next, %73 ]
  %51 = load ptr, ptr %40, align 8, !tbaa !5
  %52 = getelementptr inbounds ptr, ptr %51, i64 %indvars.iv
  %53 = load ptr, ptr %52, align 8, !tbaa !25
  %54 = getelementptr inbounds i8, ptr %53, i64 2
  %55 = load i16, ptr %54, align 2, !tbaa !26
  %56 = getelementptr inbounds i8, ptr %53, i64 8
  %57 = load ptr, ptr %56, align 8, !tbaa !28
  %58 = zext i16 %55 to i64
  %59 = getelementptr inbounds ptr, ptr %57, i64 %58
  %60 = load ptr, ptr %59, align 8, !tbaa !25
  %61 = getelementptr inbounds i8, ptr %60, i64 8
  %62 = load ptr, ptr %61, align 8, !tbaa !16
  %63 = getelementptr inbounds i8, ptr %62, i64 4
  %64 = load i16, ptr %63, align 4, !tbaa !29
  %65 = load ptr, ptr %3, align 8, !tbaa !5
  %66 = getelementptr inbounds i8, ptr %65, i64 8
  %67 = load i16, ptr %66, align 8, !tbaa !21
  %.not107 = icmp ugt i16 %64, %67
  br i1 %.not107, label %73, label %68

68:                                               ; preds = %49
  %69 = zext i16 %64 to i64
  %70 = getelementptr inbounds i16, ptr %37, i64 %69
  %71 = load i16, ptr %70, align 2, !tbaa !22
  %72 = add i16 %71, 1
  store i16 %72, ptr %70, align 2, !tbaa !22
  %.pre = load i16, ptr %38, align 8, !tbaa !5
  br label %73

73:                                               ; preds = %68, %49
  %74 = phi i16 [ %.pre, %68 ], [ %50, %49 ]
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %75 = zext i16 %74 to i64
  %76 = icmp ult i64 %indvars.iv.next, %75
  br i1 %76, label %49, label %.preheader, !llvm.loop !31

77:                                               ; preds = %._crit_edge129
  tail call void @free(ptr noundef %2) #4
  tail call void @free(ptr noundef %37) #4
  %78 = tail call ptr @bk_build_Block(ptr noundef %30) #4
  ret ptr %78

79:                                               ; preds = %.preheader, %._crit_edge129
  %.0100130 = phi i16 [ 0, %.preheader ], [ %182, %._crit_edge129 ]
  %80 = zext i16 %.0100130 to i64
  %81 = getelementptr inbounds i16, ptr %37, i64 %80
  %82 = load i16, ptr %81, align 2, !tbaa !22
  %.not105 = icmp eq i16 %82, 0
  br i1 %.not105, label %._crit_edge129, label %83

83:                                               ; preds = %79
  %84 = zext i16 %82 to i32
  %85 = tail call ptr (i32, ...) @bk_new_Block(i32 noundef 2, i32 noundef %84, i32 noundef 0) #4
  %86 = load i16, ptr %38, align 8, !tbaa !5
  %.not133 = icmp eq i16 %86, 0
  br i1 %.not133, label %._crit_edge129, label %.lr.ph128

.lr.ph128:                                        ; preds = %83, %177
  %87 = phi i16 [ %178, %177 ], [ %86, %83 ]
  %indvars.iv149 = phi i64 [ %indvars.iv.next150, %177 ], [ 0, %83 ]
  %88 = load ptr, ptr %48, align 8, !tbaa !5
  %89 = getelementptr inbounds ptr, ptr %88, i64 %indvars.iv149
  %90 = load ptr, ptr %89, align 8, !tbaa !25
  %91 = getelementptr inbounds i8, ptr %90, i64 8
  %92 = load ptr, ptr %91, align 8, !tbaa !28
  %93 = getelementptr inbounds i8, ptr %90, i64 2
  %94 = load i16, ptr %93, align 2, !tbaa !26
  %95 = zext i16 %94 to i64
  %96 = getelementptr inbounds ptr, ptr %92, i64 %95
  %97 = load ptr, ptr %96, align 8, !tbaa !25
  %98 = getelementptr inbounds i8, ptr %97, i64 8
  %99 = load ptr, ptr %98, align 8, !tbaa !16
  %100 = getelementptr inbounds i8, ptr %99, i64 4
  %101 = load i16, ptr %100, align 4, !tbaa !29
  %.not106 = icmp eq i16 %101, %.0100130
  br i1 %.not106, label %102, label %177

102:                                              ; preds = %.lr.ph128
  tail call void @reverseBacktracks(ptr noundef nonnull %90)
  %103 = load i16, ptr %93, align 2, !tbaa !26
  %104 = getelementptr inbounds i8, ptr %90, i64 4
  %105 = load i16, ptr %104, align 4, !tbaa !32
  %106 = zext i16 %103 to i32
  %107 = sub i16 %105, %103
  %108 = load i16, ptr %90, align 8, !tbaa !33
  %109 = sub i16 %108, %105
  %110 = getelementptr inbounds i8, ptr %90, i64 16
  %111 = load i16, ptr %110, align 8, !tbaa !34
  %112 = tail call ptr (i32, ...) @bk_new_Block(i32 noundef 0) #4
  %113 = tail call ptr (ptr, i32, ...) @bk_push(ptr noundef %112, i32 noundef 2, i32 noundef %106, i32 noundef 0) #4
  %114 = load i16, ptr %93, align 2, !tbaa !26
  %.not134 = icmp eq i16 %114, 0
  br i1 %.not134, label %._crit_edge, label %.lr.ph112

._crit_edge:                                      ; preds = %.lr.ph112, %102
  %115 = zext i16 %107 to i32
  %116 = tail call ptr (ptr, i32, ...) @bk_push(ptr noundef %112, i32 noundef 2, i32 noundef %115, i32 noundef 0) #4
  %117 = load i16, ptr %93, align 2, !tbaa !26
  %.096113 = add i16 %117, 1
  %118 = load i16, ptr %104, align 4, !tbaa !32
  %119 = icmp ult i16 %.096113, %118
  br i1 %119, label %.lr.ph116.preheader, label %._crit_edge117

.lr.ph116.preheader:                              ; preds = %._crit_edge
  %120 = zext i16 %.096113 to i64
  br label %.lr.ph116

.lr.ph112:                                        ; preds = %102, %.lr.ph112
  %indvars.iv137 = phi i64 [ %indvars.iv.next138, %.lr.ph112 ], [ 0, %102 ]
  %121 = load ptr, ptr %91, align 8, !tbaa !28
  %122 = getelementptr inbounds ptr, ptr %121, i64 %indvars.iv137
  %123 = load ptr, ptr %122, align 8, !tbaa !25
  %124 = getelementptr inbounds i8, ptr %123, i64 8
  %125 = load ptr, ptr %124, align 8, !tbaa !16
  %126 = getelementptr inbounds i8, ptr %125, i64 4
  %127 = load i16, ptr %126, align 4, !tbaa !29
  %128 = zext i16 %127 to i32
  %129 = tail call ptr (ptr, i32, ...) @bk_push(ptr noundef %112, i32 noundef 2, i32 noundef %128, i32 noundef 0) #4
  %indvars.iv.next138 = add nuw nsw i64 %indvars.iv137, 1
  %130 = load i16, ptr %93, align 2, !tbaa !26
  %131 = zext i16 %130 to i64
  %132 = icmp ult i64 %indvars.iv.next138, %131
  br i1 %132, label %.lr.ph112, label %._crit_edge, !llvm.loop !35

._crit_edge117:                                   ; preds = %.lr.ph116, %._crit_edge
  %133 = zext i16 %109 to i32
  %134 = tail call ptr (ptr, i32, ...) @bk_push(ptr noundef %112, i32 noundef 2, i32 noundef %133, i32 noundef 0) #4
  %135 = load i16, ptr %104, align 4, !tbaa !32
  %136 = load i16, ptr %90, align 8, !tbaa !33
  %137 = icmp ult i16 %135, %136
  br i1 %137, label %.lr.ph120.preheader, label %._crit_edge121

.lr.ph120.preheader:                              ; preds = %._crit_edge117
  %138 = zext i16 %135 to i64
  br label %.lr.ph120

.lr.ph116:                                        ; preds = %.lr.ph116.preheader, %.lr.ph116
  %indvars.iv140 = phi i64 [ %120, %.lr.ph116.preheader ], [ %indvars.iv.next141, %.lr.ph116 ]
  %139 = load ptr, ptr %91, align 8, !tbaa !28
  %140 = getelementptr inbounds ptr, ptr %139, i64 %indvars.iv140
  %141 = load ptr, ptr %140, align 8, !tbaa !25
  %142 = getelementptr inbounds i8, ptr %141, i64 8
  %143 = load ptr, ptr %142, align 8, !tbaa !16
  %144 = getelementptr inbounds i8, ptr %143, i64 4
  %145 = load i16, ptr %144, align 4, !tbaa !29
  %146 = zext i16 %145 to i32
  %147 = tail call ptr (ptr, i32, ...) @bk_push(ptr noundef %112, i32 noundef 2, i32 noundef %146, i32 noundef 0) #4
  %indvars.iv.next141 = add nuw nsw i64 %indvars.iv140, 1
  %148 = load i16, ptr %104, align 4, !tbaa !32
  %149 = zext i16 %148 to i64
  %150 = icmp ult i64 %indvars.iv.next141, %149
  br i1 %150, label %.lr.ph116, label %._crit_edge117, !llvm.loop !36

._crit_edge121:                                   ; preds = %.lr.ph120, %._crit_edge117
  %151 = zext i16 %111 to i32
  %152 = tail call ptr (ptr, i32, ...) @bk_push(ptr noundef %112, i32 noundef 2, i32 noundef %151, i32 noundef 0) #4
  %.not135 = icmp eq i16 %111, 0
  br i1 %.not135, label %._crit_edge125, label %.lr.ph124

.lr.ph124:                                        ; preds = %._crit_edge121
  %153 = getelementptr inbounds i8, ptr %90, i64 24
  %wide.trip.count = zext i16 %111 to i64
  br label %167

.lr.ph120:                                        ; preds = %.lr.ph120.preheader, %.lr.ph120
  %indvars.iv143 = phi i64 [ %138, %.lr.ph120.preheader ], [ %indvars.iv.next144, %.lr.ph120 ]
  %154 = load ptr, ptr %91, align 8, !tbaa !28
  %155 = getelementptr inbounds ptr, ptr %154, i64 %indvars.iv143
  %156 = load ptr, ptr %155, align 8, !tbaa !25
  %157 = getelementptr inbounds i8, ptr %156, i64 8
  %158 = load ptr, ptr %157, align 8, !tbaa !16
  %159 = getelementptr inbounds i8, ptr %158, i64 4
  %160 = load i16, ptr %159, align 4, !tbaa !29
  %161 = zext i16 %160 to i32
  %162 = tail call ptr (ptr, i32, ...) @bk_push(ptr noundef %112, i32 noundef 2, i32 noundef %161, i32 noundef 0) #4
  %indvars.iv.next144 = add nuw nsw i64 %indvars.iv143, 1
  %163 = load i16, ptr %90, align 8, !tbaa !33
  %164 = zext i16 %163 to i64
  %165 = icmp ult i64 %indvars.iv.next144, %164
  br i1 %165, label %.lr.ph120, label %._crit_edge121, !llvm.loop !37

._crit_edge125:                                   ; preds = %167, %._crit_edge121
  %166 = tail call ptr (ptr, i32, ...) @bk_push(ptr noundef %85, i32 noundef 16, ptr noundef %112, i32 noundef 0) #4
  %.pre152 = load i16, ptr %38, align 8, !tbaa !5
  br label %177

167:                                              ; preds = %.lr.ph124, %167
  %indvars.iv146 = phi i64 [ 0, %.lr.ph124 ], [ %indvars.iv.next147, %167 ]
  %168 = load ptr, ptr %153, align 8, !tbaa !38
  %169 = getelementptr inbounds %struct.otl_ChainLookupApplication, ptr %168, i64 %indvars.iv146
  %170 = load i16, ptr %169, align 8, !tbaa !39
  %171 = zext i16 %170 to i32
  %172 = sub nsw i32 %171, %106
  %173 = getelementptr inbounds i8, ptr %169, i64 12
  %174 = load i16, ptr %173, align 4, !tbaa !41
  %175 = zext i16 %174 to i32
  %176 = tail call ptr (ptr, i32, ...) @bk_push(ptr noundef %112, i32 noundef 2, i32 noundef %172, i32 noundef 2, i32 noundef %175, i32 noundef 0) #4
  %indvars.iv.next147 = add nuw nsw i64 %indvars.iv146, 1
  %exitcond.not = icmp eq i64 %indvars.iv.next147, %wide.trip.count
  br i1 %exitcond.not, label %._crit_edge125, label %167, !llvm.loop !42

177:                                              ; preds = %.lr.ph128, %._crit_edge125
  %178 = phi i16 [ %87, %.lr.ph128 ], [ %.pre152, %._crit_edge125 ]
  %indvars.iv.next150 = add nuw nsw i64 %indvars.iv149, 1
  %179 = zext i16 %178 to i64
  %180 = icmp ult i64 %indvars.iv.next150, %179
  br i1 %180, label %.lr.ph128, label %._crit_edge129, !llvm.loop !43

._crit_edge129:                                   ; preds = %177, %79, %83
  %.sink = phi ptr [ %85, %83 ], [ null, %79 ], [ %85, %177 ]
  %181 = tail call ptr (ptr, i32, ...) @bk_push(ptr noundef %30, i32 noundef 16, ptr noundef %.sink, i32 noundef 0) #4
  %182 = add i16 %.0100130, 1
  %183 = load ptr, ptr %3, align 8, !tbaa !5
  %184 = getelementptr inbounds i8, ptr %183, i64 8
  %185 = load i16, ptr %184, align 8, !tbaa !21
  %.not104 = icmp ugt i16 %182, %185
  br i1 %.not104, label %77, label %79, !llvm.loop !44
}

; Function Attrs: inlinehint nounwind uwtable
declare hidden ptr @__caryll_allocate_clean(i64 noundef, i64 noundef) local_unnamed_addr #0

; Function Attrs: mustprogress nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite)
declare void @free(ptr allocptr nocapture noundef) local_unnamed_addr #3

attributes #0 = { inlinehint 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 #1 = { "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 #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 = { mustprogress nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" "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 #4 = { 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 = !{!"omnipotent char", !7, i64 0}
!7 = !{!"Simple C/C++ TBAA"}
!8 = !{!9, !10, i64 0}
!9 = !{!"", !10, i64 0, !11, i64 4, !10, i64 8, !12, i64 16, !12, i64 24}
!10 = !{!"short", !6, i64 0}
!11 = !{!"int", !6, i64 0}
!12 = !{!"any pointer", !6, i64 0}
!13 = !{!14, !10, i64 0}
!14 = !{!"", !10, i64 0, !11, i64 4, !12, i64 8}
!15 = !{!9, !12, i64 16}
!16 = !{!14, !12, i64 8}
!17 = !{!18, !12, i64 96}
!18 = !{!"__otfcc_ICoverage", !12, i64 0, !12, i64 8, !12, i64 16, !12, i64 24, !12, i64 32, !12, i64 40, !12, i64 48, !12, i64 56, !12, i64 64, !12, i64 72, !12, i64 80, !12, i64 88, !12, i64 96, !12, i64 104, !12, i64 112, !12, i64 120}
!19 = !{!20, !12, i64 104}
!20 = !{!"__otfcc_IClassDef", !12, i64 0, !12, i64 8, !12, i64 16, !12, i64 24, !12, i64 32, !12, i64 40, !12, i64 48, !12, i64 56, !12, i64 64, !12, i64 72, !12, i64 80, !12, i64 88, !12, i64 96, !12, i64 104, !12, i64 112}
!21 = !{!9, !10, i64 8}
!22 = !{!10, !10, i64 0}
!23 = distinct !{!23, !24}
!24 = !{!"llvm.loop.mustprogress"}
!25 = !{!12, !12, i64 0}
!26 = !{!27, !10, i64 2}
!27 = !{!"", !10, i64 0, !10, i64 2, !10, i64 4, !12, i64 8, !10, i64 16, !12, i64 24}
!28 = !{!27, !12, i64 8}
!29 = !{!30, !10, i64 4}
!30 = !{!"otfcc_Handle", !11, i64 0, !10, i64 4, !12, i64 8}
!31 = distinct !{!31, !24}
!32 = !{!27, !10, i64 4}
!33 = !{!27, !10, i64 0}
!34 = !{!27, !10, i64 16}
!35 = distinct !{!35, !24}
!36 = distinct !{!36, !24}
!37 = distinct !{!37, !24}
!38 = !{!27, !12, i64 24}
!39 = !{!40, !10, i64 0}
!40 = !{!"", !10, i64 0, !30, i64 8}
!41 = !{!40, !10, i64 12}
!42 = distinct !{!42, !24}
!43 = distinct !{!43, !24}
!44 = distinct !{!44, !24}


; Effective O3 passes: CorrelatedValuePropagationPass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferFunctionAttrsPass,InstCombinePass,JumpThreadingPass,LICMPass,LoopRotatePass,LoopSimplifyPass,LoopUnrollPass,PostOrderFunctionAttrsPass,ReassociatePass,SROAPass,SimplifyCFGPass,TailCallElimPass