; LLVM IR from caryll/otfcc :: lib/consolidate/otl (gpos-cursive)

; 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_GlyphOrderPackage = type { ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr }
%struct.__caryll_vectorinterface_subtable_gpos_cursive = type { ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr }
%struct.otfcc_HandlePackage = type { ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr }
%struct.otl_GposCursiveEntry = type { %struct.otfcc_Handle, %struct.otl_Anchor, %struct.otl_Anchor }
%struct.otfcc_Handle = type { i32, i16, ptr }
%struct.otl_Anchor = type { i8, double, double }
%struct.subtable_gpos_cursive = type { i64, i64, ptr }
%struct._caryll_font = type { i32, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr }
%struct.otfcc_Options = type { i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, ptr, ptr }
%struct.otfcc_ILogger = type { ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr }
%struct.gpos_cursive_hash = type { i32, ptr, %struct.otl_Anchor, %struct.otl_Anchor, %struct.UT_hash_handle }
%struct.UT_hash_handle = type { ptr, ptr, ptr, ptr, ptr, ptr, i32, i32 }
%struct.UT_hash_table = type { ptr, i32, i32, i32, ptr, i64, i32, i32, i32, i32, i32 }
%struct.UT_hash_bucket = type { ptr, i32, i32 }

@otfcc_pkgGlyphOrder = external constant %struct.otfcc_GlyphOrderPackage, align 8
@.str = external hidden unnamed_addr constant [42 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [68 x i8], align 1
@iSubtable_gpos_cursive = external constant %struct.__caryll_vectorinterface_subtable_gpos_cursive, align 8
@otfcc_iHandle = external constant %struct.otfcc_HandlePackage, align 8

; Function Attrs: nounwind uwtable
define dso_local zeroext i1 @consolidate_gpos_cursive(ptr noundef %0, ptr noundef %1, ptr noundef %2, ptr noundef %3) #0 {
  %5 = alloca ptr, align 8
  %6 = alloca ptr, align 8
  %7 = alloca ptr, align 8
  %8 = alloca ptr, align 8
  %9 = alloca ptr, align 8
  %10 = alloca ptr, align 8
  %11 = alloca i16, align 2
  %12 = alloca ptr, align 8
  %13 = alloca i32, align 4
  %14 = alloca i32, align 4
  %15 = alloca i32, align 4
  %16 = alloca i32, align 4
  %17 = alloca i32, align 4
  %18 = alloca ptr, align 8
  %19 = alloca i32, align 4
  %20 = alloca i32, align 4
  %21 = alloca i32, align 4
  %22 = alloca i32, align 4
  %23 = alloca i32, align 4
  %24 = alloca ptr, align 8
  %25 = alloca i32, align 4
  %26 = alloca ptr, align 8
  %27 = alloca i32, align 4
  %28 = alloca i32, align 4
  %29 = alloca ptr, align 8
  %30 = alloca ptr, align 8
  %31 = alloca ptr, align 8
  %32 = alloca ptr, align 8
  %33 = alloca i32, align 4
  %34 = alloca i32, align 4
  %35 = alloca i32, align 4
  %36 = alloca i32, align 4
  %37 = alloca i32, align 4
  %38 = alloca i32, align 4
  %39 = alloca ptr, align 8
  %40 = alloca ptr, align 8
  %41 = alloca ptr, align 8
  %42 = alloca ptr, align 8
  %43 = alloca ptr, align 8
  %44 = alloca ptr, align 8
  %45 = alloca ptr, align 8
  %46 = alloca %struct.otl_GposCursiveEntry, align 8
  %47 = alloca ptr, align 8
  %48 = alloca i32, align 4
  %49 = alloca ptr, align 8
  store ptr %0, ptr %5, align 8, !tbaa !5
  store ptr %1, ptr %6, align 8, !tbaa !5
  store ptr %2, ptr %7, align 8, !tbaa !5
  store ptr %3, ptr %8, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %9) #10
  %50 = load ptr, ptr %7, align 8, !tbaa !5
  store ptr %50, ptr %9, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %10) #10
  store ptr null, ptr %10, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 2, ptr %11) #10
  store i16 0, ptr %11, align 2, !tbaa !9
  br label %51

51:                                               ; preds = %1489, %4
  %52 = load i16, ptr %11, align 2, !tbaa !9
  %53 = zext i16 %52 to i64
  %54 = load ptr, ptr %9, align 8, !tbaa !5
  %55 = getelementptr inbounds %struct.subtable_gpos_cursive, ptr %54, i32 0, i32 0
  %56 = load i64, ptr %55, align 8, !tbaa !11
  %57 = icmp ult i64 %53, %56
  br i1 %57, label %59, label %58

58:                                               ; preds = %51
  call void @llvm.lifetime.end.p0(i64 2, ptr %11) #10
  br label %1492

59:                                               ; preds = %51
  %60 = load ptr, ptr getelementptr inbounds (%struct.otfcc_GlyphOrderPackage, ptr @otfcc_pkgGlyphOrder, i32 0, i32 11), align 8, !tbaa !14
  %61 = load ptr, ptr %5, align 8, !tbaa !5
  %62 = getelementptr inbounds %struct._caryll_font, ptr %61, i32 0, i32 33
  %63 = load ptr, ptr %62, align 8, !tbaa !16
  %64 = load ptr, ptr %9, align 8, !tbaa !5
  %65 = getelementptr inbounds %struct.subtable_gpos_cursive, ptr %64, i32 0, i32 2
  %66 = load ptr, ptr %65, align 8, !tbaa !19
  %67 = load i16, ptr %11, align 2, !tbaa !9
  %68 = zext i16 %67 to i64
  %69 = getelementptr inbounds %struct.otl_GposCursiveEntry, ptr %66, i64 %68
  %70 = getelementptr inbounds %struct.otl_GposCursiveEntry, ptr %69, i32 0, i32 0
  %71 = call zeroext i1 %60(ptr noundef %63, ptr noundef %70)
  br i1 %71, label %92, label %72

72:                                               ; preds = %59
  %73 = load ptr, ptr %8, align 8, !tbaa !5
  %74 = getelementptr inbounds %struct.otfcc_Options, ptr %73, i32 0, i32 24
  %75 = load ptr, ptr %74, align 8, !tbaa !20
  %76 = getelementptr inbounds %struct.otfcc_ILogger, ptr %75, i32 0, i32 6
  %77 = load ptr, ptr %76, align 8, !tbaa !23
  %78 = load ptr, ptr %8, align 8, !tbaa !5
  %79 = getelementptr inbounds %struct.otfcc_Options, ptr %78, i32 0, i32 24
  %80 = load ptr, ptr %79, align 8, !tbaa !20
  %81 = call ptr @sdsempty()
  %82 = load ptr, ptr %9, align 8, !tbaa !5
  %83 = getelementptr inbounds %struct.subtable_gpos_cursive, ptr %82, i32 0, i32 2
  %84 = load ptr, ptr %83, align 8, !tbaa !19
  %85 = load i16, ptr %11, align 2, !tbaa !9
  %86 = zext i16 %85 to i64
  %87 = getelementptr inbounds %struct.otl_GposCursiveEntry, ptr %84, i64 %86
  %88 = getelementptr inbounds %struct.otl_GposCursiveEntry, ptr %87, i32 0, i32 0
  %89 = getelementptr inbounds %struct.otfcc_Handle, ptr %88, i32 0, i32 2
  %90 = load ptr, ptr %89, align 8, !tbaa !25
  %91 = call ptr (ptr, ptr, ...) @sdscatprintf(ptr noundef %81, ptr noundef @.str, ptr noundef %90)
  call void %77(ptr noundef %80, i8 noundef zeroext 1, i32 noundef 1, ptr noundef %91)
  br label %1489

92:                                               ; preds = %59
  call void @llvm.lifetime.start.p0(i64 8, ptr %12) #10
  call void @llvm.lifetime.start.p0(i64 4, ptr %13) #10
  %93 = load ptr, ptr %9, align 8, !tbaa !5
  %94 = getelementptr inbounds %struct.subtable_gpos_cursive, ptr %93, i32 0, i32 2
  %95 = load ptr, ptr %94, align 8, !tbaa !19
  %96 = load i16, ptr %11, align 2, !tbaa !9
  %97 = zext i16 %96 to i64
  %98 = getelementptr inbounds %struct.otl_GposCursiveEntry, ptr %95, i64 %97
  %99 = getelementptr inbounds %struct.otl_GposCursiveEntry, ptr %98, i32 0, i32 0
  %100 = getelementptr inbounds %struct.otfcc_Handle, ptr %99, i32 0, i32 1
  %101 = load i16, ptr %100, align 4, !tbaa !30
  %102 = zext i16 %101 to i32
  store i32 %102, ptr %13, align 4, !tbaa !31
  br label %103

103:                                              ; preds = %92
  call void @llvm.lifetime.start.p0(i64 4, ptr %14) #10
  br label %104

104:                                              ; preds = %103
  br label %105

105:                                              ; preds = %104
  call void @llvm.lifetime.start.p0(i64 4, ptr %15) #10
  call void @llvm.lifetime.start.p0(i64 4, ptr %16) #10
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #10
  call void @llvm.lifetime.start.p0(i64 8, ptr %18) #10
  store ptr %13, ptr %18, align 8, !tbaa !5
  store i32 -17973521, ptr %14, align 4, !tbaa !31
  store i32 -1640531527, ptr %16, align 4, !tbaa !31
  store i32 -1640531527, ptr %15, align 4, !tbaa !31
  store i32 4, ptr %17, align 4, !tbaa !31
  br label %106

106:                                              ; preds = %274, %105
  %107 = load i32, ptr %17, align 4, !tbaa !31
  %108 = icmp uge i32 %107, 12
  br i1 %108, label %109, label %279

109:                                              ; preds = %106
  %110 = load ptr, ptr %18, align 8, !tbaa !5
  %111 = getelementptr inbounds i8, ptr %110, i64 0
  %112 = load i8, ptr %111, align 1, !tbaa !32
  %113 = zext i8 %112 to i32
  %114 = load ptr, ptr %18, align 8, !tbaa !5
  %115 = getelementptr inbounds i8, ptr %114, i64 1
  %116 = load i8, ptr %115, align 1, !tbaa !32
  %117 = zext i8 %116 to i32
  %118 = shl i32 %117, 8
  %119 = add i32 %113, %118
  %120 = load ptr, ptr %18, align 8, !tbaa !5
  %121 = getelementptr inbounds i8, ptr %120, i64 2
  %122 = load i8, ptr %121, align 1, !tbaa !32
  %123 = zext i8 %122 to i32
  %124 = shl i32 %123, 16
  %125 = add i32 %119, %124
  %126 = load ptr, ptr %18, align 8, !tbaa !5
  %127 = getelementptr inbounds i8, ptr %126, i64 3
  %128 = load i8, ptr %127, align 1, !tbaa !32
  %129 = zext i8 %128 to i32
  %130 = shl i32 %129, 24
  %131 = add i32 %125, %130
  %132 = load i32, ptr %15, align 4, !tbaa !31
  %133 = add i32 %132, %131
  store i32 %133, ptr %15, align 4, !tbaa !31
  %134 = load ptr, ptr %18, align 8, !tbaa !5
  %135 = getelementptr inbounds i8, ptr %134, i64 4
  %136 = load i8, ptr %135, align 1, !tbaa !32
  %137 = zext i8 %136 to i32
  %138 = load ptr, ptr %18, align 8, !tbaa !5
  %139 = getelementptr inbounds i8, ptr %138, i64 5
  %140 = load i8, ptr %139, align 1, !tbaa !32
  %141 = zext i8 %140 to i32
  %142 = shl i32 %141, 8
  %143 = add i32 %137, %142
  %144 = load ptr, ptr %18, align 8, !tbaa !5
  %145 = getelementptr inbounds i8, ptr %144, i64 6
  %146 = load i8, ptr %145, align 1, !tbaa !32
  %147 = zext i8 %146 to i32
  %148 = shl i32 %147, 16
  %149 = add i32 %143, %148
  %150 = load ptr, ptr %18, align 8, !tbaa !5
  %151 = getelementptr inbounds i8, ptr %150, i64 7
  %152 = load i8, ptr %151, align 1, !tbaa !32
  %153 = zext i8 %152 to i32
  %154 = shl i32 %153, 24
  %155 = add i32 %149, %154
  %156 = load i32, ptr %16, align 4, !tbaa !31
  %157 = add i32 %156, %155
  store i32 %157, ptr %16, align 4, !tbaa !31
  %158 = load ptr, ptr %18, align 8, !tbaa !5
  %159 = getelementptr inbounds i8, ptr %158, i64 8
  %160 = load i8, ptr %159, align 1, !tbaa !32
  %161 = zext i8 %160 to i32
  %162 = load ptr, ptr %18, align 8, !tbaa !5
  %163 = getelementptr inbounds i8, ptr %162, i64 9
  %164 = load i8, ptr %163, align 1, !tbaa !32
  %165 = zext i8 %164 to i32
  %166 = shl i32 %165, 8
  %167 = add i32 %161, %166
  %168 = load ptr, ptr %18, align 8, !tbaa !5
  %169 = getelementptr inbounds i8, ptr %168, i64 10
  %170 = load i8, ptr %169, align 1, !tbaa !32
  %171 = zext i8 %170 to i32
  %172 = shl i32 %171, 16
  %173 = add i32 %167, %172
  %174 = load ptr, ptr %18, align 8, !tbaa !5
  %175 = getelementptr inbounds i8, ptr %174, i64 11
  %176 = load i8, ptr %175, align 1, !tbaa !32
  %177 = zext i8 %176 to i32
  %178 = shl i32 %177, 24
  %179 = add i32 %173, %178
  %180 = load i32, ptr %14, align 4, !tbaa !31
  %181 = add i32 %180, %179
  store i32 %181, ptr %14, align 4, !tbaa !31
  br label %182

182:                                              ; preds = %109
  %183 = load i32, ptr %16, align 4, !tbaa !31
  %184 = load i32, ptr %15, align 4, !tbaa !31
  %185 = sub i32 %184, %183
  store i32 %185, ptr %15, align 4, !tbaa !31
  %186 = load i32, ptr %14, align 4, !tbaa !31
  %187 = load i32, ptr %15, align 4, !tbaa !31
  %188 = sub i32 %187, %186
  store i32 %188, ptr %15, align 4, !tbaa !31
  %189 = load i32, ptr %14, align 4, !tbaa !31
  %190 = lshr i32 %189, 13
  %191 = load i32, ptr %15, align 4, !tbaa !31
  %192 = xor i32 %191, %190
  store i32 %192, ptr %15, align 4, !tbaa !31
  %193 = load i32, ptr %14, align 4, !tbaa !31
  %194 = load i32, ptr %16, align 4, !tbaa !31
  %195 = sub i32 %194, %193
  store i32 %195, ptr %16, align 4, !tbaa !31
  %196 = load i32, ptr %15, align 4, !tbaa !31
  %197 = load i32, ptr %16, align 4, !tbaa !31
  %198 = sub i32 %197, %196
  store i32 %198, ptr %16, align 4, !tbaa !31
  %199 = load i32, ptr %15, align 4, !tbaa !31
  %200 = shl i32 %199, 8
  %201 = load i32, ptr %16, align 4, !tbaa !31
  %202 = xor i32 %201, %200
  store i32 %202, ptr %16, align 4, !tbaa !31
  %203 = load i32, ptr %15, align 4, !tbaa !31
  %204 = load i32, ptr %14, align 4, !tbaa !31
  %205 = sub i32 %204, %203
  store i32 %205, ptr %14, align 4, !tbaa !31
  %206 = load i32, ptr %16, align 4, !tbaa !31
  %207 = load i32, ptr %14, align 4, !tbaa !31
  %208 = sub i32 %207, %206
  store i32 %208, ptr %14, align 4, !tbaa !31
  %209 = load i32, ptr %16, align 4, !tbaa !31
  %210 = lshr i32 %209, 13
  %211 = load i32, ptr %14, align 4, !tbaa !31
  %212 = xor i32 %211, %210
  store i32 %212, ptr %14, align 4, !tbaa !31
  %213 = load i32, ptr %16, align 4, !tbaa !31
  %214 = load i32, ptr %15, align 4, !tbaa !31
  %215 = sub i32 %214, %213
  store i32 %215, ptr %15, align 4, !tbaa !31
  %216 = load i32, ptr %14, align 4, !tbaa !31
  %217 = load i32, ptr %15, align 4, !tbaa !31
  %218 = sub i32 %217, %216
  store i32 %218, ptr %15, align 4, !tbaa !31
  %219 = load i32, ptr %14, align 4, !tbaa !31
  %220 = lshr i32 %219, 12
  %221 = load i32, ptr %15, align 4, !tbaa !31
  %222 = xor i32 %221, %220
  store i32 %222, ptr %15, align 4, !tbaa !31
  %223 = load i32, ptr %14, align 4, !tbaa !31
  %224 = load i32, ptr %16, align 4, !tbaa !31
  %225 = sub i32 %224, %223
  store i32 %225, ptr %16, align 4, !tbaa !31
  %226 = load i32, ptr %15, align 4, !tbaa !31
  %227 = load i32, ptr %16, align 4, !tbaa !31
  %228 = sub i32 %227, %226
  store i32 %228, ptr %16, align 4, !tbaa !31
  %229 = load i32, ptr %15, align 4, !tbaa !31
  %230 = shl i32 %229, 16
  %231 = load i32, ptr %16, align 4, !tbaa !31
  %232 = xor i32 %231, %230
  store i32 %232, ptr %16, align 4, !tbaa !31
  %233 = load i32, ptr %15, align 4, !tbaa !31
  %234 = load i32, ptr %14, align 4, !tbaa !31
  %235 = sub i32 %234, %233
  store i32 %235, ptr %14, align 4, !tbaa !31
  %236 = load i32, ptr %16, align 4, !tbaa !31
  %237 = load i32, ptr %14, align 4, !tbaa !31
  %238 = sub i32 %237, %236
  store i32 %238, ptr %14, align 4, !tbaa !31
  %239 = load i32, ptr %16, align 4, !tbaa !31
  %240 = lshr i32 %239, 5
  %241 = load i32, ptr %14, align 4, !tbaa !31
  %242 = xor i32 %241, %240
  store i32 %242, ptr %14, align 4, !tbaa !31
  %243 = load i32, ptr %16, align 4, !tbaa !31
  %244 = load i32, ptr %15, align 4, !tbaa !31
  %245 = sub i32 %244, %243
  store i32 %245, ptr %15, align 4, !tbaa !31
  %246 = load i32, ptr %14, align 4, !tbaa !31
  %247 = load i32, ptr %15, align 4, !tbaa !31
  %248 = sub i32 %247, %246
  store i32 %248, ptr %15, align 4, !tbaa !31
  %249 = load i32, ptr %14, align 4, !tbaa !31
  %250 = lshr i32 %249, 3
  %251 = load i32, ptr %15, align 4, !tbaa !31
  %252 = xor i32 %251, %250
  store i32 %252, ptr %15, align 4, !tbaa !31
  %253 = load i32, ptr %14, align 4, !tbaa !31
  %254 = load i32, ptr %16, align 4, !tbaa !31
  %255 = sub i32 %254, %253
  store i32 %255, ptr %16, align 4, !tbaa !31
  %256 = load i32, ptr %15, align 4, !tbaa !31
  %257 = load i32, ptr %16, align 4, !tbaa !31
  %258 = sub i32 %257, %256
  store i32 %258, ptr %16, align 4, !tbaa !31
  %259 = load i32, ptr %15, align 4, !tbaa !31
  %260 = shl i32 %259, 10
  %261 = load i32, ptr %16, align 4, !tbaa !31
  %262 = xor i32 %261, %260
  store i32 %262, ptr %16, align 4, !tbaa !31
  %263 = load i32, ptr %15, align 4, !tbaa !31
  %264 = load i32, ptr %14, align 4, !tbaa !31
  %265 = sub i32 %264, %263
  store i32 %265, ptr %14, align 4, !tbaa !31
  %266 = load i32, ptr %16, align 4, !tbaa !31
  %267 = load i32, ptr %14, align 4, !tbaa !31
  %268 = sub i32 %267, %266
  store i32 %268, ptr %14, align 4, !tbaa !31
  %269 = load i32, ptr %16, align 4, !tbaa !31
  %270 = lshr i32 %269, 15
  %271 = load i32, ptr %14, align 4, !tbaa !31
  %272 = xor i32 %271, %270
  store i32 %272, ptr %14, align 4, !tbaa !31
  br label %273

273:                                              ; preds = %182
  br label %274

274:                                              ; preds = %273
  %275 = load ptr, ptr %18, align 8, !tbaa !5
  %276 = getelementptr inbounds i8, ptr %275, i64 12
  store ptr %276, ptr %18, align 8, !tbaa !5
  %277 = load i32, ptr %17, align 4, !tbaa !31
  %278 = sub i32 %277, 12
  store i32 %278, ptr %17, align 4, !tbaa !31
  br label %106, !llvm.loop !33

279:                                              ; preds = %106
  %280 = load i32, ptr %14, align 4, !tbaa !31
  %281 = add i32 %280, 4
  store i32 %281, ptr %14, align 4, !tbaa !31
  %282 = load i32, ptr %17, align 4, !tbaa !31
  switch i32 %282, label %369 [
    i32 11, label %283
    i32 10, label %291
    i32 9, label %299
    i32 8, label %307
    i32 7, label %315
    i32 6, label %323
    i32 5, label %331
    i32 4, label %338
    i32 3, label %346
    i32 2, label %354
    i32 1, label %362
  ]

283:                                              ; preds = %279
  %284 = load ptr, ptr %18, align 8, !tbaa !5
  %285 = getelementptr inbounds i8, ptr %284, i64 10
  %286 = load i8, ptr %285, align 1, !tbaa !32
  %287 = zext i8 %286 to i32
  %288 = shl i32 %287, 24
  %289 = load i32, ptr %14, align 4, !tbaa !31
  %290 = add i32 %289, %288
  store i32 %290, ptr %14, align 4, !tbaa !31
  br label %291

291:                                              ; preds = %283, %279
  %292 = load ptr, ptr %18, align 8, !tbaa !5
  %293 = getelementptr inbounds i8, ptr %292, i64 9
  %294 = load i8, ptr %293, align 1, !tbaa !32
  %295 = zext i8 %294 to i32
  %296 = shl i32 %295, 16
  %297 = load i32, ptr %14, align 4, !tbaa !31
  %298 = add i32 %297, %296
  store i32 %298, ptr %14, align 4, !tbaa !31
  br label %299

299:                                              ; preds = %291, %279
  %300 = load ptr, ptr %18, align 8, !tbaa !5
  %301 = getelementptr inbounds i8, ptr %300, i64 8
  %302 = load i8, ptr %301, align 1, !tbaa !32
  %303 = zext i8 %302 to i32
  %304 = shl i32 %303, 8
  %305 = load i32, ptr %14, align 4, !tbaa !31
  %306 = add i32 %305, %304
  store i32 %306, ptr %14, align 4, !tbaa !31
  br label %307

307:                                              ; preds = %299, %279
  %308 = load ptr, ptr %18, align 8, !tbaa !5
  %309 = getelementptr inbounds i8, ptr %308, i64 7
  %310 = load i8, ptr %309, align 1, !tbaa !32
  %311 = zext i8 %310 to i32
  %312 = shl i32 %311, 24
  %313 = load i32, ptr %16, align 4, !tbaa !31
  %314 = add i32 %313, %312
  store i32 %314, ptr %16, align 4, !tbaa !31
  br label %315

315:                                              ; preds = %307, %279
  %316 = load ptr, ptr %18, align 8, !tbaa !5
  %317 = getelementptr inbounds i8, ptr %316, i64 6
  %318 = load i8, ptr %317, align 1, !tbaa !32
  %319 = zext i8 %318 to i32
  %320 = shl i32 %319, 16
  %321 = load i32, ptr %16, align 4, !tbaa !31
  %322 = add i32 %321, %320
  store i32 %322, ptr %16, align 4, !tbaa !31
  br label %323

323:                                              ; preds = %315, %279
  %324 = load ptr, ptr %18, align 8, !tbaa !5
  %325 = getelementptr inbounds i8, ptr %324, i64 5
  %326 = load i8, ptr %325, align 1, !tbaa !32
  %327 = zext i8 %326 to i32
  %328 = shl i32 %327, 8
  %329 = load i32, ptr %16, align 4, !tbaa !31
  %330 = add i32 %329, %328
  store i32 %330, ptr %16, align 4, !tbaa !31
  br label %331

331:                                              ; preds = %323, %279
  %332 = load ptr, ptr %18, align 8, !tbaa !5
  %333 = getelementptr inbounds i8, ptr %332, i64 4
  %334 = load i8, ptr %333, align 1, !tbaa !32
  %335 = zext i8 %334 to i32
  %336 = load i32, ptr %16, align 4, !tbaa !31
  %337 = add i32 %336, %335
  store i32 %337, ptr %16, align 4, !tbaa !31
  br label %338

338:                                              ; preds = %331, %279
  %339 = load ptr, ptr %18, align 8, !tbaa !5
  %340 = getelementptr inbounds i8, ptr %339, i64 3
  %341 = load i8, ptr %340, align 1, !tbaa !32
  %342 = zext i8 %341 to i32
  %343 = shl i32 %342, 24
  %344 = load i32, ptr %15, align 4, !tbaa !31
  %345 = add i32 %344, %343
  store i32 %345, ptr %15, align 4, !tbaa !31
  br label %346

346:                                              ; preds = %338, %279
  %347 = load ptr, ptr %18, align 8, !tbaa !5
  %348 = getelementptr inbounds i8, ptr %347, i64 2
  %349 = load i8, ptr %348, align 1, !tbaa !32
  %350 = zext i8 %349 to i32
  %351 = shl i32 %350, 16
  %352 = load i32, ptr %15, align 4, !tbaa !31
  %353 = add i32 %352, %351
  store i32 %353, ptr %15, align 4, !tbaa !31
  br label %354

354:                                              ; preds = %346, %279
  %355 = load ptr, ptr %18, align 8, !tbaa !5
  %356 = getelementptr inbounds i8, ptr %355, i64 1
  %357 = load i8, ptr %356, align 1, !tbaa !32
  %358 = zext i8 %357 to i32
  %359 = shl i32 %358, 8
  %360 = load i32, ptr %15, align 4, !tbaa !31
  %361 = add i32 %360, %359
  store i32 %361, ptr %15, align 4, !tbaa !31
  br label %362

362:                                              ; preds = %354, %279
  %363 = load ptr, ptr %18, align 8, !tbaa !5
  %364 = getelementptr inbounds i8, ptr %363, i64 0
  %365 = load i8, ptr %364, align 1, !tbaa !32
  %366 = zext i8 %365 to i32
  %367 = load i32, ptr %15, align 4, !tbaa !31
  %368 = add i32 %367, %366
  store i32 %368, ptr %15, align 4, !tbaa !31
  br label %369

369:                                              ; preds = %362, %279
  br label %370

370:                                              ; preds = %369
  %371 = load i32, ptr %16, align 4, !tbaa !31
  %372 = load i32, ptr %15, align 4, !tbaa !31
  %373 = sub i32 %372, %371
  store i32 %373, ptr %15, align 4, !tbaa !31
  %374 = load i32, ptr %14, align 4, !tbaa !31
  %375 = load i32, ptr %15, align 4, !tbaa !31
  %376 = sub i32 %375, %374
  store i32 %376, ptr %15, align 4, !tbaa !31
  %377 = load i32, ptr %14, align 4, !tbaa !31
  %378 = lshr i32 %377, 13
  %379 = load i32, ptr %15, align 4, !tbaa !31
  %380 = xor i32 %379, %378
  store i32 %380, ptr %15, align 4, !tbaa !31
  %381 = load i32, ptr %14, align 4, !tbaa !31
  %382 = load i32, ptr %16, align 4, !tbaa !31
  %383 = sub i32 %382, %381
  store i32 %383, ptr %16, align 4, !tbaa !31
  %384 = load i32, ptr %15, align 4, !tbaa !31
  %385 = load i32, ptr %16, align 4, !tbaa !31
  %386 = sub i32 %385, %384
  store i32 %386, ptr %16, align 4, !tbaa !31
  %387 = load i32, ptr %15, align 4, !tbaa !31
  %388 = shl i32 %387, 8
  %389 = load i32, ptr %16, align 4, !tbaa !31
  %390 = xor i32 %389, %388
  store i32 %390, ptr %16, align 4, !tbaa !31
  %391 = load i32, ptr %15, align 4, !tbaa !31
  %392 = load i32, ptr %14, align 4, !tbaa !31
  %393 = sub i32 %392, %391
  store i32 %393, ptr %14, align 4, !tbaa !31
  %394 = load i32, ptr %16, align 4, !tbaa !31
  %395 = load i32, ptr %14, align 4, !tbaa !31
  %396 = sub i32 %395, %394
  store i32 %396, ptr %14, align 4, !tbaa !31
  %397 = load i32, ptr %16, align 4, !tbaa !31
  %398 = lshr i32 %397, 13
  %399 = load i32, ptr %14, align 4, !tbaa !31
  %400 = xor i32 %399, %398
  store i32 %400, ptr %14, align 4, !tbaa !31
  %401 = load i32, ptr %16, align 4, !tbaa !31
  %402 = load i32, ptr %15, align 4, !tbaa !31
  %403 = sub i32 %402, %401
  store i32 %403, ptr %15, align 4, !tbaa !31
  %404 = load i32, ptr %14, align 4, !tbaa !31
  %405 = load i32, ptr %15, align 4, !tbaa !31
  %406 = sub i32 %405, %404
  store i32 %406, ptr %15, align 4, !tbaa !31
  %407 = load i32, ptr %14, align 4, !tbaa !31
  %408 = lshr i32 %407, 12
  %409 = load i32, ptr %15, align 4, !tbaa !31
  %410 = xor i32 %409, %408
  store i32 %410, ptr %15, align 4, !tbaa !31
  %411 = load i32, ptr %14, align 4, !tbaa !31
  %412 = load i32, ptr %16, align 4, !tbaa !31
  %413 = sub i32 %412, %411
  store i32 %413, ptr %16, align 4, !tbaa !31
  %414 = load i32, ptr %15, align 4, !tbaa !31
  %415 = load i32, ptr %16, align 4, !tbaa !31
  %416 = sub i32 %415, %414
  store i32 %416, ptr %16, align 4, !tbaa !31
  %417 = load i32, ptr %15, align 4, !tbaa !31
  %418 = shl i32 %417, 16
  %419 = load i32, ptr %16, align 4, !tbaa !31
  %420 = xor i32 %419, %418
  store i32 %420, ptr %16, align 4, !tbaa !31
  %421 = load i32, ptr %15, align 4, !tbaa !31
  %422 = load i32, ptr %14, align 4, !tbaa !31
  %423 = sub i32 %422, %421
  store i32 %423, ptr %14, align 4, !tbaa !31
  %424 = load i32, ptr %16, align 4, !tbaa !31
  %425 = load i32, ptr %14, align 4, !tbaa !31
  %426 = sub i32 %425, %424
  store i32 %426, ptr %14, align 4, !tbaa !31
  %427 = load i32, ptr %16, align 4, !tbaa !31
  %428 = lshr i32 %427, 5
  %429 = load i32, ptr %14, align 4, !tbaa !31
  %430 = xor i32 %429, %428
  store i32 %430, ptr %14, align 4, !tbaa !31
  %431 = load i32, ptr %16, align 4, !tbaa !31
  %432 = load i32, ptr %15, align 4, !tbaa !31
  %433 = sub i32 %432, %431
  store i32 %433, ptr %15, align 4, !tbaa !31
  %434 = load i32, ptr %14, align 4, !tbaa !31
  %435 = load i32, ptr %15, align 4, !tbaa !31
  %436 = sub i32 %435, %434
  store i32 %436, ptr %15, align 4, !tbaa !31
  %437 = load i32, ptr %14, align 4, !tbaa !31
  %438 = lshr i32 %437, 3
  %439 = load i32, ptr %15, align 4, !tbaa !31
  %440 = xor i32 %439, %438
  store i32 %440, ptr %15, align 4, !tbaa !31
  %441 = load i32, ptr %14, align 4, !tbaa !31
  %442 = load i32, ptr %16, align 4, !tbaa !31
  %443 = sub i32 %442, %441
  store i32 %443, ptr %16, align 4, !tbaa !31
  %444 = load i32, ptr %15, align 4, !tbaa !31
  %445 = load i32, ptr %16, align 4, !tbaa !31
  %446 = sub i32 %445, %444
  store i32 %446, ptr %16, align 4, !tbaa !31
  %447 = load i32, ptr %15, align 4, !tbaa !31
  %448 = shl i32 %447, 10
  %449 = load i32, ptr %16, align 4, !tbaa !31
  %450 = xor i32 %449, %448
  store i32 %450, ptr %16, align 4, !tbaa !31
  %451 = load i32, ptr %15, align 4, !tbaa !31
  %452 = load i32, ptr %14, align 4, !tbaa !31
  %453 = sub i32 %452, %451
  store i32 %453, ptr %14, align 4, !tbaa !31
  %454 = load i32, ptr %16, align 4, !tbaa !31
  %455 = load i32, ptr %14, align 4, !tbaa !31
  %456 = sub i32 %455, %454
  store i32 %456, ptr %14, align 4, !tbaa !31
  %457 = load i32, ptr %16, align 4, !tbaa !31
  %458 = lshr i32 %457, 15
  %459 = load i32, ptr %14, align 4, !tbaa !31
  %460 = xor i32 %459, %458
  store i32 %460, ptr %14, align 4, !tbaa !31
  br label %461

461:                                              ; preds = %370
  br label %462

462:                                              ; preds = %461
  call void @llvm.lifetime.end.p0(i64 8, ptr %18) #10
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #10
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #10
  call void @llvm.lifetime.end.p0(i64 4, ptr %15) #10
  br label %463

463:                                              ; preds = %462
  br label %464

464:                                              ; preds = %463
  br label %465

465:                                              ; preds = %464
  br label %466

466:                                              ; preds = %465
  br label %467

467:                                              ; preds = %466
  store ptr null, ptr %12, align 8, !tbaa !5
  %468 = load ptr, ptr %10, align 8, !tbaa !5
  %469 = icmp ne ptr %468, null
  br i1 %469, label %470, label %574

470:                                              ; preds = %467
  call void @llvm.lifetime.start.p0(i64 4, ptr %19) #10
  br label %471

471:                                              ; preds = %470
  %472 = load i32, ptr %14, align 4, !tbaa !31
  %473 = load ptr, ptr %10, align 8, !tbaa !5
  %474 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %473, i32 0, i32 4
  %475 = getelementptr inbounds %struct.UT_hash_handle, ptr %474, i32 0, i32 0
  %476 = load ptr, ptr %475, align 8, !tbaa !35
  %477 = getelementptr inbounds %struct.UT_hash_table, ptr %476, i32 0, i32 1
  %478 = load i32, ptr %477, align 8, !tbaa !38
  %479 = sub i32 %478, 1
  %480 = and i32 %472, %479
  store i32 %480, ptr %19, align 4, !tbaa !31
  br label %481

481:                                              ; preds = %471
  br label %482

482:                                              ; preds = %481
  br label %483

483:                                              ; preds = %482
  %484 = load ptr, ptr %10, align 8, !tbaa !5
  %485 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %484, i32 0, i32 4
  %486 = getelementptr inbounds %struct.UT_hash_handle, ptr %485, i32 0, i32 0
  %487 = load ptr, ptr %486, align 8, !tbaa !35
  %488 = getelementptr inbounds %struct.UT_hash_table, ptr %487, i32 0, i32 0
  %489 = load ptr, ptr %488, align 8, !tbaa !40
  %490 = load i32, ptr %19, align 4, !tbaa !31
  %491 = zext i32 %490 to i64
  %492 = getelementptr inbounds %struct.UT_hash_bucket, ptr %489, i64 %491
  %493 = getelementptr inbounds %struct.UT_hash_bucket, ptr %492, i32 0, i32 0
  %494 = load ptr, ptr %493, align 8, !tbaa !41
  %495 = icmp ne ptr %494, null
  br i1 %495, label %496, label %519

496:                                              ; preds = %483
  br label %497

497:                                              ; preds = %496
  %498 = load ptr, ptr %10, align 8, !tbaa !5
  %499 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %498, i32 0, i32 4
  %500 = getelementptr inbounds %struct.UT_hash_handle, ptr %499, i32 0, i32 0
  %501 = load ptr, ptr %500, align 8, !tbaa !35
  %502 = getelementptr inbounds %struct.UT_hash_table, ptr %501, i32 0, i32 0
  %503 = load ptr, ptr %502, align 8, !tbaa !40
  %504 = load i32, ptr %19, align 4, !tbaa !31
  %505 = zext i32 %504 to i64
  %506 = getelementptr inbounds %struct.UT_hash_bucket, ptr %503, i64 %505
  %507 = getelementptr inbounds %struct.UT_hash_bucket, ptr %506, i32 0, i32 0
  %508 = load ptr, ptr %507, align 8, !tbaa !41
  %509 = load ptr, ptr %10, align 8, !tbaa !5
  %510 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %509, i32 0, i32 4
  %511 = getelementptr inbounds %struct.UT_hash_handle, ptr %510, i32 0, i32 0
  %512 = load ptr, ptr %511, align 8, !tbaa !35
  %513 = getelementptr inbounds %struct.UT_hash_table, ptr %512, i32 0, i32 5
  %514 = load i64, ptr %513, align 8, !tbaa !43
  %515 = sub i64 0, %514
  %516 = getelementptr inbounds i8, ptr %508, i64 %515
  store ptr %516, ptr %12, align 8, !tbaa !5
  br label %517

517:                                              ; preds = %497
  br label %518

518:                                              ; preds = %517
  br label %520

519:                                              ; preds = %483
  store ptr null, ptr %12, align 8, !tbaa !5
  br label %520

520:                                              ; preds = %519, %518
  br label %521

521:                                              ; preds = %570, %520
  %522 = load ptr, ptr %12, align 8, !tbaa !5
  %523 = icmp ne ptr %522, null
  br i1 %523, label %524, label %571

524:                                              ; preds = %521
  %525 = load ptr, ptr %12, align 8, !tbaa !5
  %526 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %525, i32 0, i32 4
  %527 = getelementptr inbounds %struct.UT_hash_handle, ptr %526, i32 0, i32 7
  %528 = load i32, ptr %527, align 4, !tbaa !44
  %529 = load i32, ptr %14, align 4, !tbaa !31
  %530 = icmp eq i32 %528, %529
  br i1 %530, label %531, label %547

531:                                              ; preds = %524
  %532 = load ptr, ptr %12, align 8, !tbaa !5
  %533 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %532, i32 0, i32 4
  %534 = getelementptr inbounds %struct.UT_hash_handle, ptr %533, i32 0, i32 6
  %535 = load i32, ptr %534, align 8, !tbaa !45
  %536 = zext i32 %535 to i64
  %537 = icmp eq i64 %536, 4
  br i1 %537, label %538, label %547

538:                                              ; preds = %531
  %539 = load ptr, ptr %12, align 8, !tbaa !5
  %540 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %539, i32 0, i32 4
  %541 = getelementptr inbounds %struct.UT_hash_handle, ptr %540, i32 0, i32 5
  %542 = load ptr, ptr %541, align 8, !tbaa !46
  %543 = call i32 @memcmp(ptr noundef %542, ptr noundef %13, i64 noundef 4) #11
  %544 = icmp eq i32 %543, 0
  br i1 %544, label %545, label %546

545:                                              ; preds = %538
  br label %571

546:                                              ; preds = %538
  br label %547

547:                                              ; preds = %546, %531, %524
  %548 = load ptr, ptr %12, align 8, !tbaa !5
  %549 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %548, i32 0, i32 4
  %550 = getelementptr inbounds %struct.UT_hash_handle, ptr %549, i32 0, i32 4
  %551 = load ptr, ptr %550, align 8, !tbaa !47
  %552 = icmp ne ptr %551, null
  br i1 %552, label %553, label %569

553:                                              ; preds = %547
  br label %554

554:                                              ; preds = %553
  %555 = load ptr, ptr %12, align 8, !tbaa !5
  %556 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %555, i32 0, i32 4
  %557 = getelementptr inbounds %struct.UT_hash_handle, ptr %556, i32 0, i32 4
  %558 = load ptr, ptr %557, align 8, !tbaa !47
  %559 = load ptr, ptr %10, align 8, !tbaa !5
  %560 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %559, i32 0, i32 4
  %561 = getelementptr inbounds %struct.UT_hash_handle, ptr %560, i32 0, i32 0
  %562 = load ptr, ptr %561, align 8, !tbaa !35
  %563 = getelementptr inbounds %struct.UT_hash_table, ptr %562, i32 0, i32 5
  %564 = load i64, ptr %563, align 8, !tbaa !43
  %565 = sub i64 0, %564
  %566 = getelementptr inbounds i8, ptr %558, i64 %565
  store ptr %566, ptr %12, align 8, !tbaa !5
  br label %567

567:                                              ; preds = %554
  br label %568

568:                                              ; preds = %567
  br label %570

569:                                              ; preds = %547
  store ptr null, ptr %12, align 8, !tbaa !5
  br label %570

570:                                              ; preds = %569, %568
  br label %521, !llvm.loop !48

571:                                              ; preds = %545, %521
  br label %572

572:                                              ; preds = %571
  br label %573

573:                                              ; preds = %572
  call void @llvm.lifetime.end.p0(i64 4, ptr %19) #10
  br label %574

574:                                              ; preds = %573, %467
  br label %575

575:                                              ; preds = %574
  br label %576

576:                                              ; preds = %575
  call void @llvm.lifetime.end.p0(i64 4, ptr %14) #10
  br label %577

577:                                              ; preds = %576
  br label %578

578:                                              ; preds = %577
  %579 = load ptr, ptr %12, align 8, !tbaa !5
  %580 = icmp ne ptr %579, null
  br i1 %580, label %581, label %601

581:                                              ; preds = %578
  %582 = load ptr, ptr %8, align 8, !tbaa !5
  %583 = getelementptr inbounds %struct.otfcc_Options, ptr %582, i32 0, i32 24
  %584 = load ptr, ptr %583, align 8, !tbaa !20
  %585 = getelementptr inbounds %struct.otfcc_ILogger, ptr %584, i32 0, i32 6
  %586 = load ptr, ptr %585, align 8, !tbaa !23
  %587 = load ptr, ptr %8, align 8, !tbaa !5
  %588 = getelementptr inbounds %struct.otfcc_Options, ptr %587, i32 0, i32 24
  %589 = load ptr, ptr %588, align 8, !tbaa !20
  %590 = call ptr @sdsempty()
  %591 = load ptr, ptr %9, align 8, !tbaa !5
  %592 = getelementptr inbounds %struct.subtable_gpos_cursive, ptr %591, i32 0, i32 2
  %593 = load ptr, ptr %592, align 8, !tbaa !19
  %594 = load i16, ptr %11, align 2, !tbaa !9
  %595 = zext i16 %594 to i64
  %596 = getelementptr inbounds %struct.otl_GposCursiveEntry, ptr %593, i64 %595
  %597 = getelementptr inbounds %struct.otl_GposCursiveEntry, ptr %596, i32 0, i32 0
  %598 = getelementptr inbounds %struct.otfcc_Handle, ptr %597, i32 0, i32 2
  %599 = load ptr, ptr %598, align 8, !tbaa !25
  %600 = call ptr (ptr, ptr, ...) @sdscatprintf(ptr noundef %590, ptr noundef @.str.1, ptr noundef %599)
  call void %586(ptr noundef %589, i8 noundef zeroext 1, i32 noundef 1, ptr noundef %600)
  br label %1488

601:                                              ; preds = %578
  %602 = call ptr @__caryll_allocate_clean(i64 noundef 120, i64 noundef 30)
  store ptr %602, ptr %12, align 8, !tbaa !5
  %603 = load ptr, ptr %9, align 8, !tbaa !5
  %604 = getelementptr inbounds %struct.subtable_gpos_cursive, ptr %603, i32 0, i32 2
  %605 = load ptr, ptr %604, align 8, !tbaa !19
  %606 = load i16, ptr %11, align 2, !tbaa !9
  %607 = zext i16 %606 to i64
  %608 = getelementptr inbounds %struct.otl_GposCursiveEntry, ptr %605, i64 %607
  %609 = getelementptr inbounds %struct.otl_GposCursiveEntry, ptr %608, i32 0, i32 0
  %610 = getelementptr inbounds %struct.otfcc_Handle, ptr %609, i32 0, i32 1
  %611 = load i16, ptr %610, align 4, !tbaa !30
  %612 = zext i16 %611 to i32
  %613 = load ptr, ptr %12, align 8, !tbaa !5
  %614 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %613, i32 0, i32 0
  store i32 %612, ptr %614, align 8, !tbaa !49
  %615 = load ptr, ptr %9, align 8, !tbaa !5
  %616 = getelementptr inbounds %struct.subtable_gpos_cursive, ptr %615, i32 0, i32 2
  %617 = load ptr, ptr %616, align 8, !tbaa !19
  %618 = load i16, ptr %11, align 2, !tbaa !9
  %619 = zext i16 %618 to i64
  %620 = getelementptr inbounds %struct.otl_GposCursiveEntry, ptr %617, i64 %619
  %621 = getelementptr inbounds %struct.otl_GposCursiveEntry, ptr %620, i32 0, i32 0
  %622 = getelementptr inbounds %struct.otfcc_Handle, ptr %621, i32 0, i32 2
  %623 = load ptr, ptr %622, align 8, !tbaa !25
  %624 = call ptr @sdsdup(ptr noundef %623)
  %625 = load ptr, ptr %12, align 8, !tbaa !5
  %626 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %625, i32 0, i32 1
  store ptr %624, ptr %626, align 8, !tbaa !50
  %627 = load ptr, ptr %12, align 8, !tbaa !5
  %628 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %627, i32 0, i32 2
  %629 = load ptr, ptr %9, align 8, !tbaa !5
  %630 = getelementptr inbounds %struct.subtable_gpos_cursive, ptr %629, i32 0, i32 2
  %631 = load ptr, ptr %630, align 8, !tbaa !19
  %632 = load i16, ptr %11, align 2, !tbaa !9
  %633 = zext i16 %632 to i64
  %634 = getelementptr inbounds %struct.otl_GposCursiveEntry, ptr %631, i64 %633
  %635 = getelementptr inbounds %struct.otl_GposCursiveEntry, ptr %634, i32 0, i32 1
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %628, ptr align 8 %635, i64 24, i1 false), !tbaa.struct !51
  %636 = load ptr, ptr %12, align 8, !tbaa !5
  %637 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %636, i32 0, i32 3
  %638 = load ptr, ptr %9, align 8, !tbaa !5
  %639 = getelementptr inbounds %struct.subtable_gpos_cursive, ptr %638, i32 0, i32 2
  %640 = load ptr, ptr %639, align 8, !tbaa !19
  %641 = load i16, ptr %11, align 2, !tbaa !9
  %642 = zext i16 %641 to i64
  %643 = getelementptr inbounds %struct.otl_GposCursiveEntry, ptr %640, i64 %642
  %644 = getelementptr inbounds %struct.otl_GposCursiveEntry, ptr %643, i32 0, i32 2
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %637, ptr align 8 %644, i64 24, i1 false), !tbaa.struct !51
  br label %645

645:                                              ; preds = %601
  call void @llvm.lifetime.start.p0(i64 4, ptr %20) #10
  br label %646

646:                                              ; preds = %645
  br label %647

647:                                              ; preds = %646
  call void @llvm.lifetime.start.p0(i64 4, ptr %21) #10
  call void @llvm.lifetime.start.p0(i64 4, ptr %22) #10
  call void @llvm.lifetime.start.p0(i64 4, ptr %23) #10
  call void @llvm.lifetime.start.p0(i64 8, ptr %24) #10
  %648 = load ptr, ptr %12, align 8, !tbaa !5
  %649 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %648, i32 0, i32 0
  store ptr %649, ptr %24, align 8, !tbaa !5
  store i32 -17973521, ptr %20, align 4, !tbaa !31
  store i32 -1640531527, ptr %22, align 4, !tbaa !31
  store i32 -1640531527, ptr %21, align 4, !tbaa !31
  store i32 4, ptr %23, align 4, !tbaa !31
  br label %650

650:                                              ; preds = %818, %647
  %651 = load i32, ptr %23, align 4, !tbaa !31
  %652 = icmp uge i32 %651, 12
  br i1 %652, label %653, label %823

653:                                              ; preds = %650
  %654 = load ptr, ptr %24, align 8, !tbaa !5
  %655 = getelementptr inbounds i8, ptr %654, i64 0
  %656 = load i8, ptr %655, align 1, !tbaa !32
  %657 = zext i8 %656 to i32
  %658 = load ptr, ptr %24, align 8, !tbaa !5
  %659 = getelementptr inbounds i8, ptr %658, i64 1
  %660 = load i8, ptr %659, align 1, !tbaa !32
  %661 = zext i8 %660 to i32
  %662 = shl i32 %661, 8
  %663 = add i32 %657, %662
  %664 = load ptr, ptr %24, align 8, !tbaa !5
  %665 = getelementptr inbounds i8, ptr %664, i64 2
  %666 = load i8, ptr %665, align 1, !tbaa !32
  %667 = zext i8 %666 to i32
  %668 = shl i32 %667, 16
  %669 = add i32 %663, %668
  %670 = load ptr, ptr %24, align 8, !tbaa !5
  %671 = getelementptr inbounds i8, ptr %670, i64 3
  %672 = load i8, ptr %671, align 1, !tbaa !32
  %673 = zext i8 %672 to i32
  %674 = shl i32 %673, 24
  %675 = add i32 %669, %674
  %676 = load i32, ptr %21, align 4, !tbaa !31
  %677 = add i32 %676, %675
  store i32 %677, ptr %21, align 4, !tbaa !31
  %678 = load ptr, ptr %24, align 8, !tbaa !5
  %679 = getelementptr inbounds i8, ptr %678, i64 4
  %680 = load i8, ptr %679, align 1, !tbaa !32
  %681 = zext i8 %680 to i32
  %682 = load ptr, ptr %24, align 8, !tbaa !5
  %683 = getelementptr inbounds i8, ptr %682, i64 5
  %684 = load i8, ptr %683, align 1, !tbaa !32
  %685 = zext i8 %684 to i32
  %686 = shl i32 %685, 8
  %687 = add i32 %681, %686
  %688 = load ptr, ptr %24, align 8, !tbaa !5
  %689 = getelementptr inbounds i8, ptr %688, i64 6
  %690 = load i8, ptr %689, align 1, !tbaa !32
  %691 = zext i8 %690 to i32
  %692 = shl i32 %691, 16
  %693 = add i32 %687, %692
  %694 = load ptr, ptr %24, align 8, !tbaa !5
  %695 = getelementptr inbounds i8, ptr %694, i64 7
  %696 = load i8, ptr %695, align 1, !tbaa !32
  %697 = zext i8 %696 to i32
  %698 = shl i32 %697, 24
  %699 = add i32 %693, %698
  %700 = load i32, ptr %22, align 4, !tbaa !31
  %701 = add i32 %700, %699
  store i32 %701, ptr %22, align 4, !tbaa !31
  %702 = load ptr, ptr %24, align 8, !tbaa !5
  %703 = getelementptr inbounds i8, ptr %702, i64 8
  %704 = load i8, ptr %703, align 1, !tbaa !32
  %705 = zext i8 %704 to i32
  %706 = load ptr, ptr %24, align 8, !tbaa !5
  %707 = getelementptr inbounds i8, ptr %706, i64 9
  %708 = load i8, ptr %707, align 1, !tbaa !32
  %709 = zext i8 %708 to i32
  %710 = shl i32 %709, 8
  %711 = add i32 %705, %710
  %712 = load ptr, ptr %24, align 8, !tbaa !5
  %713 = getelementptr inbounds i8, ptr %712, i64 10
  %714 = load i8, ptr %713, align 1, !tbaa !32
  %715 = zext i8 %714 to i32
  %716 = shl i32 %715, 16
  %717 = add i32 %711, %716
  %718 = load ptr, ptr %24, align 8, !tbaa !5
  %719 = getelementptr inbounds i8, ptr %718, i64 11
  %720 = load i8, ptr %719, align 1, !tbaa !32
  %721 = zext i8 %720 to i32
  %722 = shl i32 %721, 24
  %723 = add i32 %717, %722
  %724 = load i32, ptr %20, align 4, !tbaa !31
  %725 = add i32 %724, %723
  store i32 %725, ptr %20, align 4, !tbaa !31
  br label %726

726:                                              ; preds = %653
  %727 = load i32, ptr %22, align 4, !tbaa !31
  %728 = load i32, ptr %21, align 4, !tbaa !31
  %729 = sub i32 %728, %727
  store i32 %729, ptr %21, align 4, !tbaa !31
  %730 = load i32, ptr %20, align 4, !tbaa !31
  %731 = load i32, ptr %21, align 4, !tbaa !31
  %732 = sub i32 %731, %730
  store i32 %732, ptr %21, align 4, !tbaa !31
  %733 = load i32, ptr %20, align 4, !tbaa !31
  %734 = lshr i32 %733, 13
  %735 = load i32, ptr %21, align 4, !tbaa !31
  %736 = xor i32 %735, %734
  store i32 %736, ptr %21, align 4, !tbaa !31
  %737 = load i32, ptr %20, align 4, !tbaa !31
  %738 = load i32, ptr %22, align 4, !tbaa !31
  %739 = sub i32 %738, %737
  store i32 %739, ptr %22, align 4, !tbaa !31
  %740 = load i32, ptr %21, align 4, !tbaa !31
  %741 = load i32, ptr %22, align 4, !tbaa !31
  %742 = sub i32 %741, %740
  store i32 %742, ptr %22, align 4, !tbaa !31
  %743 = load i32, ptr %21, align 4, !tbaa !31
  %744 = shl i32 %743, 8
  %745 = load i32, ptr %22, align 4, !tbaa !31
  %746 = xor i32 %745, %744
  store i32 %746, ptr %22, align 4, !tbaa !31
  %747 = load i32, ptr %21, align 4, !tbaa !31
  %748 = load i32, ptr %20, align 4, !tbaa !31
  %749 = sub i32 %748, %747
  store i32 %749, ptr %20, align 4, !tbaa !31
  %750 = load i32, ptr %22, align 4, !tbaa !31
  %751 = load i32, ptr %20, align 4, !tbaa !31
  %752 = sub i32 %751, %750
  store i32 %752, ptr %20, align 4, !tbaa !31
  %753 = load i32, ptr %22, align 4, !tbaa !31
  %754 = lshr i32 %753, 13
  %755 = load i32, ptr %20, align 4, !tbaa !31
  %756 = xor i32 %755, %754
  store i32 %756, ptr %20, align 4, !tbaa !31
  %757 = load i32, ptr %22, align 4, !tbaa !31
  %758 = load i32, ptr %21, align 4, !tbaa !31
  %759 = sub i32 %758, %757
  store i32 %759, ptr %21, align 4, !tbaa !31
  %760 = load i32, ptr %20, align 4, !tbaa !31
  %761 = load i32, ptr %21, align 4, !tbaa !31
  %762 = sub i32 %761, %760
  store i32 %762, ptr %21, align 4, !tbaa !31
  %763 = load i32, ptr %20, align 4, !tbaa !31
  %764 = lshr i32 %763, 12
  %765 = load i32, ptr %21, align 4, !tbaa !31
  %766 = xor i32 %765, %764
  store i32 %766, ptr %21, align 4, !tbaa !31
  %767 = load i32, ptr %20, align 4, !tbaa !31
  %768 = load i32, ptr %22, align 4, !tbaa !31
  %769 = sub i32 %768, %767
  store i32 %769, ptr %22, align 4, !tbaa !31
  %770 = load i32, ptr %21, align 4, !tbaa !31
  %771 = load i32, ptr %22, align 4, !tbaa !31
  %772 = sub i32 %771, %770
  store i32 %772, ptr %22, align 4, !tbaa !31
  %773 = load i32, ptr %21, align 4, !tbaa !31
  %774 = shl i32 %773, 16
  %775 = load i32, ptr %22, align 4, !tbaa !31
  %776 = xor i32 %775, %774
  store i32 %776, ptr %22, align 4, !tbaa !31
  %777 = load i32, ptr %21, align 4, !tbaa !31
  %778 = load i32, ptr %20, align 4, !tbaa !31
  %779 = sub i32 %778, %777
  store i32 %779, ptr %20, align 4, !tbaa !31
  %780 = load i32, ptr %22, align 4, !tbaa !31
  %781 = load i32, ptr %20, align 4, !tbaa !31
  %782 = sub i32 %781, %780
  store i32 %782, ptr %20, align 4, !tbaa !31
  %783 = load i32, ptr %22, align 4, !tbaa !31
  %784 = lshr i32 %783, 5
  %785 = load i32, ptr %20, align 4, !tbaa !31
  %786 = xor i32 %785, %784
  store i32 %786, ptr %20, align 4, !tbaa !31
  %787 = load i32, ptr %22, align 4, !tbaa !31
  %788 = load i32, ptr %21, align 4, !tbaa !31
  %789 = sub i32 %788, %787
  store i32 %789, ptr %21, align 4, !tbaa !31
  %790 = load i32, ptr %20, align 4, !tbaa !31
  %791 = load i32, ptr %21, align 4, !tbaa !31
  %792 = sub i32 %791, %790
  store i32 %792, ptr %21, align 4, !tbaa !31
  %793 = load i32, ptr %20, align 4, !tbaa !31
  %794 = lshr i32 %793, 3
  %795 = load i32, ptr %21, align 4, !tbaa !31
  %796 = xor i32 %795, %794
  store i32 %796, ptr %21, align 4, !tbaa !31
  %797 = load i32, ptr %20, align 4, !tbaa !31
  %798 = load i32, ptr %22, align 4, !tbaa !31
  %799 = sub i32 %798, %797
  store i32 %799, ptr %22, align 4, !tbaa !31
  %800 = load i32, ptr %21, align 4, !tbaa !31
  %801 = load i32, ptr %22, align 4, !tbaa !31
  %802 = sub i32 %801, %800
  store i32 %802, ptr %22, align 4, !tbaa !31
  %803 = load i32, ptr %21, align 4, !tbaa !31
  %804 = shl i32 %803, 10
  %805 = load i32, ptr %22, align 4, !tbaa !31
  %806 = xor i32 %805, %804
  store i32 %806, ptr %22, align 4, !tbaa !31
  %807 = load i32, ptr %21, align 4, !tbaa !31
  %808 = load i32, ptr %20, align 4, !tbaa !31
  %809 = sub i32 %808, %807
  store i32 %809, ptr %20, align 4, !tbaa !31
  %810 = load i32, ptr %22, align 4, !tbaa !31
  %811 = load i32, ptr %20, align 4, !tbaa !31
  %812 = sub i32 %811, %810
  store i32 %812, ptr %20, align 4, !tbaa !31
  %813 = load i32, ptr %22, align 4, !tbaa !31
  %814 = lshr i32 %813, 15
  %815 = load i32, ptr %20, align 4, !tbaa !31
  %816 = xor i32 %815, %814
  store i32 %816, ptr %20, align 4, !tbaa !31
  br label %817

817:                                              ; preds = %726
  br label %818

818:                                              ; preds = %817
  %819 = load ptr, ptr %24, align 8, !tbaa !5
  %820 = getelementptr inbounds i8, ptr %819, i64 12
  store ptr %820, ptr %24, align 8, !tbaa !5
  %821 = load i32, ptr %23, align 4, !tbaa !31
  %822 = sub i32 %821, 12
  store i32 %822, ptr %23, align 4, !tbaa !31
  br label %650, !llvm.loop !54

823:                                              ; preds = %650
  %824 = load i32, ptr %20, align 4, !tbaa !31
  %825 = add i32 %824, 4
  store i32 %825, ptr %20, align 4, !tbaa !31
  %826 = load i32, ptr %23, align 4, !tbaa !31
  switch i32 %826, label %913 [
    i32 11, label %827
    i32 10, label %835
    i32 9, label %843
    i32 8, label %851
    i32 7, label %859
    i32 6, label %867
    i32 5, label %875
    i32 4, label %882
    i32 3, label %890
    i32 2, label %898
    i32 1, label %906
  ]

827:                                              ; preds = %823
  %828 = load ptr, ptr %24, align 8, !tbaa !5
  %829 = getelementptr inbounds i8, ptr %828, i64 10
  %830 = load i8, ptr %829, align 1, !tbaa !32
  %831 = zext i8 %830 to i32
  %832 = shl i32 %831, 24
  %833 = load i32, ptr %20, align 4, !tbaa !31
  %834 = add i32 %833, %832
  store i32 %834, ptr %20, align 4, !tbaa !31
  br label %835

835:                                              ; preds = %827, %823
  %836 = load ptr, ptr %24, align 8, !tbaa !5
  %837 = getelementptr inbounds i8, ptr %836, i64 9
  %838 = load i8, ptr %837, align 1, !tbaa !32
  %839 = zext i8 %838 to i32
  %840 = shl i32 %839, 16
  %841 = load i32, ptr %20, align 4, !tbaa !31
  %842 = add i32 %841, %840
  store i32 %842, ptr %20, align 4, !tbaa !31
  br label %843

843:                                              ; preds = %835, %823
  %844 = load ptr, ptr %24, align 8, !tbaa !5
  %845 = getelementptr inbounds i8, ptr %844, i64 8
  %846 = load i8, ptr %845, align 1, !tbaa !32
  %847 = zext i8 %846 to i32
  %848 = shl i32 %847, 8
  %849 = load i32, ptr %20, align 4, !tbaa !31
  %850 = add i32 %849, %848
  store i32 %850, ptr %20, align 4, !tbaa !31
  br label %851

851:                                              ; preds = %843, %823
  %852 = load ptr, ptr %24, align 8, !tbaa !5
  %853 = getelementptr inbounds i8, ptr %852, i64 7
  %854 = load i8, ptr %853, align 1, !tbaa !32
  %855 = zext i8 %854 to i32
  %856 = shl i32 %855, 24
  %857 = load i32, ptr %22, align 4, !tbaa !31
  %858 = add i32 %857, %856
  store i32 %858, ptr %22, align 4, !tbaa !31
  br label %859

859:                                              ; preds = %851, %823
  %860 = load ptr, ptr %24, align 8, !tbaa !5
  %861 = getelementptr inbounds i8, ptr %860, i64 6
  %862 = load i8, ptr %861, align 1, !tbaa !32
  %863 = zext i8 %862 to i32
  %864 = shl i32 %863, 16
  %865 = load i32, ptr %22, align 4, !tbaa !31
  %866 = add i32 %865, %864
  store i32 %866, ptr %22, align 4, !tbaa !31
  br label %867

867:                                              ; preds = %859, %823
  %868 = load ptr, ptr %24, align 8, !tbaa !5
  %869 = getelementptr inbounds i8, ptr %868, i64 5
  %870 = load i8, ptr %869, align 1, !tbaa !32
  %871 = zext i8 %870 to i32
  %872 = shl i32 %871, 8
  %873 = load i32, ptr %22, align 4, !tbaa !31
  %874 = add i32 %873, %872
  store i32 %874, ptr %22, align 4, !tbaa !31
  br label %875

875:                                              ; preds = %867, %823
  %876 = load ptr, ptr %24, align 8, !tbaa !5
  %877 = getelementptr inbounds i8, ptr %876, i64 4
  %878 = load i8, ptr %877, align 1, !tbaa !32
  %879 = zext i8 %878 to i32
  %880 = load i32, ptr %22, align 4, !tbaa !31
  %881 = add i32 %880, %879
  store i32 %881, ptr %22, align 4, !tbaa !31
  br label %882

882:                                              ; preds = %875, %823
  %883 = load ptr, ptr %24, align 8, !tbaa !5
  %884 = getelementptr inbounds i8, ptr %883, i64 3
  %885 = load i8, ptr %884, align 1, !tbaa !32
  %886 = zext i8 %885 to i32
  %887 = shl i32 %886, 24
  %888 = load i32, ptr %21, align 4, !tbaa !31
  %889 = add i32 %888, %887
  store i32 %889, ptr %21, align 4, !tbaa !31
  br label %890

890:                                              ; preds = %882, %823
  %891 = load ptr, ptr %24, align 8, !tbaa !5
  %892 = getelementptr inbounds i8, ptr %891, i64 2
  %893 = load i8, ptr %892, align 1, !tbaa !32
  %894 = zext i8 %893 to i32
  %895 = shl i32 %894, 16
  %896 = load i32, ptr %21, align 4, !tbaa !31
  %897 = add i32 %896, %895
  store i32 %897, ptr %21, align 4, !tbaa !31
  br label %898

898:                                              ; preds = %890, %823
  %899 = load ptr, ptr %24, align 8, !tbaa !5
  %900 = getelementptr inbounds i8, ptr %899, i64 1
  %901 = load i8, ptr %900, align 1, !tbaa !32
  %902 = zext i8 %901 to i32
  %903 = shl i32 %902, 8
  %904 = load i32, ptr %21, align 4, !tbaa !31
  %905 = add i32 %904, %903
  store i32 %905, ptr %21, align 4, !tbaa !31
  br label %906

906:                                              ; preds = %898, %823
  %907 = load ptr, ptr %24, align 8, !tbaa !5
  %908 = getelementptr inbounds i8, ptr %907, i64 0
  %909 = load i8, ptr %908, align 1, !tbaa !32
  %910 = zext i8 %909 to i32
  %911 = load i32, ptr %21, align 4, !tbaa !31
  %912 = add i32 %911, %910
  store i32 %912, ptr %21, align 4, !tbaa !31
  br label %913

913:                                              ; preds = %906, %823
  br label %914

914:                                              ; preds = %913
  %915 = load i32, ptr %22, align 4, !tbaa !31
  %916 = load i32, ptr %21, align 4, !tbaa !31
  %917 = sub i32 %916, %915
  store i32 %917, ptr %21, align 4, !tbaa !31
  %918 = load i32, ptr %20, align 4, !tbaa !31
  %919 = load i32, ptr %21, align 4, !tbaa !31
  %920 = sub i32 %919, %918
  store i32 %920, ptr %21, align 4, !tbaa !31
  %921 = load i32, ptr %20, align 4, !tbaa !31
  %922 = lshr i32 %921, 13
  %923 = load i32, ptr %21, align 4, !tbaa !31
  %924 = xor i32 %923, %922
  store i32 %924, ptr %21, align 4, !tbaa !31
  %925 = load i32, ptr %20, align 4, !tbaa !31
  %926 = load i32, ptr %22, align 4, !tbaa !31
  %927 = sub i32 %926, %925
  store i32 %927, ptr %22, align 4, !tbaa !31
  %928 = load i32, ptr %21, align 4, !tbaa !31
  %929 = load i32, ptr %22, align 4, !tbaa !31
  %930 = sub i32 %929, %928
  store i32 %930, ptr %22, align 4, !tbaa !31
  %931 = load i32, ptr %21, align 4, !tbaa !31
  %932 = shl i32 %931, 8
  %933 = load i32, ptr %22, align 4, !tbaa !31
  %934 = xor i32 %933, %932
  store i32 %934, ptr %22, align 4, !tbaa !31
  %935 = load i32, ptr %21, align 4, !tbaa !31
  %936 = load i32, ptr %20, align 4, !tbaa !31
  %937 = sub i32 %936, %935
  store i32 %937, ptr %20, align 4, !tbaa !31
  %938 = load i32, ptr %22, align 4, !tbaa !31
  %939 = load i32, ptr %20, align 4, !tbaa !31
  %940 = sub i32 %939, %938
  store i32 %940, ptr %20, align 4, !tbaa !31
  %941 = load i32, ptr %22, align 4, !tbaa !31
  %942 = lshr i32 %941, 13
  %943 = load i32, ptr %20, align 4, !tbaa !31
  %944 = xor i32 %943, %942
  store i32 %944, ptr %20, align 4, !tbaa !31
  %945 = load i32, ptr %22, align 4, !tbaa !31
  %946 = load i32, ptr %21, align 4, !tbaa !31
  %947 = sub i32 %946, %945
  store i32 %947, ptr %21, align 4, !tbaa !31
  %948 = load i32, ptr %20, align 4, !tbaa !31
  %949 = load i32, ptr %21, align 4, !tbaa !31
  %950 = sub i32 %949, %948
  store i32 %950, ptr %21, align 4, !tbaa !31
  %951 = load i32, ptr %20, align 4, !tbaa !31
  %952 = lshr i32 %951, 12
  %953 = load i32, ptr %21, align 4, !tbaa !31
  %954 = xor i32 %953, %952
  store i32 %954, ptr %21, align 4, !tbaa !31
  %955 = load i32, ptr %20, align 4, !tbaa !31
  %956 = load i32, ptr %22, align 4, !tbaa !31
  %957 = sub i32 %956, %955
  store i32 %957, ptr %22, align 4, !tbaa !31
  %958 = load i32, ptr %21, align 4, !tbaa !31
  %959 = load i32, ptr %22, align 4, !tbaa !31
  %960 = sub i32 %959, %958
  store i32 %960, ptr %22, align 4, !tbaa !31
  %961 = load i32, ptr %21, align 4, !tbaa !31
  %962 = shl i32 %961, 16
  %963 = load i32, ptr %22, align 4, !tbaa !31
  %964 = xor i32 %963, %962
  store i32 %964, ptr %22, align 4, !tbaa !31
  %965 = load i32, ptr %21, align 4, !tbaa !31
  %966 = load i32, ptr %20, align 4, !tbaa !31
  %967 = sub i32 %966, %965
  store i32 %967, ptr %20, align 4, !tbaa !31
  %968 = load i32, ptr %22, align 4, !tbaa !31
  %969 = load i32, ptr %20, align 4, !tbaa !31
  %970 = sub i32 %969, %968
  store i32 %970, ptr %20, align 4, !tbaa !31
  %971 = load i32, ptr %22, align 4, !tbaa !31
  %972 = lshr i32 %971, 5
  %973 = load i32, ptr %20, align 4, !tbaa !31
  %974 = xor i32 %973, %972
  store i32 %974, ptr %20, align 4, !tbaa !31
  %975 = load i32, ptr %22, align 4, !tbaa !31
  %976 = load i32, ptr %21, align 4, !tbaa !31
  %977 = sub i32 %976, %975
  store i32 %977, ptr %21, align 4, !tbaa !31
  %978 = load i32, ptr %20, align 4, !tbaa !31
  %979 = load i32, ptr %21, align 4, !tbaa !31
  %980 = sub i32 %979, %978
  store i32 %980, ptr %21, align 4, !tbaa !31
  %981 = load i32, ptr %20, align 4, !tbaa !31
  %982 = lshr i32 %981, 3
  %983 = load i32, ptr %21, align 4, !tbaa !31
  %984 = xor i32 %983, %982
  store i32 %984, ptr %21, align 4, !tbaa !31
  %985 = load i32, ptr %20, align 4, !tbaa !31
  %986 = load i32, ptr %22, align 4, !tbaa !31
  %987 = sub i32 %986, %985
  store i32 %987, ptr %22, align 4, !tbaa !31
  %988 = load i32, ptr %21, align 4, !tbaa !31
  %989 = load i32, ptr %22, align 4, !tbaa !31
  %990 = sub i32 %989, %988
  store i32 %990, ptr %22, align 4, !tbaa !31
  %991 = load i32, ptr %21, align 4, !tbaa !31
  %992 = shl i32 %991, 10
  %993 = load i32, ptr %22, align 4, !tbaa !31
  %994 = xor i32 %993, %992
  store i32 %994, ptr %22, align 4, !tbaa !31
  %995 = load i32, ptr %21, align 4, !tbaa !31
  %996 = load i32, ptr %20, align 4, !tbaa !31
  %997 = sub i32 %996, %995
  store i32 %997, ptr %20, align 4, !tbaa !31
  %998 = load i32, ptr %22, align 4, !tbaa !31
  %999 = load i32, ptr %20, align 4, !tbaa !31
  %1000 = sub i32 %999, %998
  store i32 %1000, ptr %20, align 4, !tbaa !31
  %1001 = load i32, ptr %22, align 4, !tbaa !31
  %1002 = lshr i32 %1001, 15
  %1003 = load i32, ptr %20, align 4, !tbaa !31
  %1004 = xor i32 %1003, %1002
  store i32 %1004, ptr %20, align 4, !tbaa !31
  br label %1005

1005:                                             ; preds = %914
  br label %1006

1006:                                             ; preds = %1005
  call void @llvm.lifetime.end.p0(i64 8, ptr %24) #10
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #10
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #10
  call void @llvm.lifetime.end.p0(i64 4, ptr %21) #10
  br label %1007

1007:                                             ; preds = %1006
  br label %1008

1008:                                             ; preds = %1007
  br label %1009

1009:                                             ; preds = %1008
  br label %1010

1010:                                             ; preds = %1009
  br label %1011

1011:                                             ; preds = %1010
  %1012 = load i32, ptr %20, align 4, !tbaa !31
  %1013 = load ptr, ptr %12, align 8, !tbaa !5
  %1014 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1013, i32 0, i32 4
  %1015 = getelementptr inbounds %struct.UT_hash_handle, ptr %1014, i32 0, i32 7
  store i32 %1012, ptr %1015, align 4, !tbaa !44
  %1016 = load ptr, ptr %12, align 8, !tbaa !5
  %1017 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1016, i32 0, i32 0
  %1018 = load ptr, ptr %12, align 8, !tbaa !5
  %1019 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1018, i32 0, i32 4
  %1020 = getelementptr inbounds %struct.UT_hash_handle, ptr %1019, i32 0, i32 5
  store ptr %1017, ptr %1020, align 8, !tbaa !46
  %1021 = load ptr, ptr %12, align 8, !tbaa !5
  %1022 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1021, i32 0, i32 4
  %1023 = getelementptr inbounds %struct.UT_hash_handle, ptr %1022, i32 0, i32 6
  store i32 4, ptr %1023, align 8, !tbaa !45
  %1024 = load ptr, ptr %10, align 8, !tbaa !5
  %1025 = icmp ne ptr %1024, null
  br i1 %1025, label %1108, label %1026

1026:                                             ; preds = %1011
  %1027 = load ptr, ptr %12, align 8, !tbaa !5
  %1028 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1027, i32 0, i32 4
  %1029 = getelementptr inbounds %struct.UT_hash_handle, ptr %1028, i32 0, i32 2
  store ptr null, ptr %1029, align 8, !tbaa !55
  %1030 = load ptr, ptr %12, align 8, !tbaa !5
  %1031 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1030, i32 0, i32 4
  %1032 = getelementptr inbounds %struct.UT_hash_handle, ptr %1031, i32 0, i32 1
  store ptr null, ptr %1032, align 8, !tbaa !56
  br label %1033

1033:                                             ; preds = %1026
  %1034 = call noalias ptr @malloc(i64 noundef 64) #12
  %1035 = load ptr, ptr %12, align 8, !tbaa !5
  %1036 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1035, i32 0, i32 4
  %1037 = getelementptr inbounds %struct.UT_hash_handle, ptr %1036, i32 0, i32 0
  store ptr %1034, ptr %1037, align 8, !tbaa !35
  %1038 = load ptr, ptr %12, align 8, !tbaa !5
  %1039 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1038, i32 0, i32 4
  %1040 = getelementptr inbounds %struct.UT_hash_handle, ptr %1039, i32 0, i32 0
  %1041 = load ptr, ptr %1040, align 8, !tbaa !35
  %1042 = icmp ne ptr %1041, null
  br i1 %1042, label %1044, label %1043

1043:                                             ; preds = %1033
  call void @exit(i32 noundef -1) #13
  unreachable

1044:                                             ; preds = %1033
  %1045 = load ptr, ptr %12, align 8, !tbaa !5
  %1046 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1045, i32 0, i32 4
  %1047 = getelementptr inbounds %struct.UT_hash_handle, ptr %1046, i32 0, i32 0
  %1048 = load ptr, ptr %1047, align 8, !tbaa !35
  call void @llvm.memset.p0.i64(ptr align 8 %1048, i8 0, i64 64, i1 false)
  %1049 = load ptr, ptr %12, align 8, !tbaa !5
  %1050 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1049, i32 0, i32 4
  %1051 = load ptr, ptr %12, align 8, !tbaa !5
  %1052 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1051, i32 0, i32 4
  %1053 = getelementptr inbounds %struct.UT_hash_handle, ptr %1052, i32 0, i32 0
  %1054 = load ptr, ptr %1053, align 8, !tbaa !35
  %1055 = getelementptr inbounds %struct.UT_hash_table, ptr %1054, i32 0, i32 4
  store ptr %1050, ptr %1055, align 8, !tbaa !57
  %1056 = load ptr, ptr %12, align 8, !tbaa !5
  %1057 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1056, i32 0, i32 4
  %1058 = getelementptr inbounds %struct.UT_hash_handle, ptr %1057, i32 0, i32 0
  %1059 = load ptr, ptr %1058, align 8, !tbaa !35
  %1060 = getelementptr inbounds %struct.UT_hash_table, ptr %1059, i32 0, i32 1
  store i32 32, ptr %1060, align 8, !tbaa !38
  %1061 = load ptr, ptr %12, align 8, !tbaa !5
  %1062 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1061, i32 0, i32 4
  %1063 = getelementptr inbounds %struct.UT_hash_handle, ptr %1062, i32 0, i32 0
  %1064 = load ptr, ptr %1063, align 8, !tbaa !35
  %1065 = getelementptr inbounds %struct.UT_hash_table, ptr %1064, i32 0, i32 2
  store i32 5, ptr %1065, align 4, !tbaa !58
  %1066 = load ptr, ptr %12, align 8, !tbaa !5
  %1067 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1066, i32 0, i32 4
  %1068 = load ptr, ptr %12, align 8, !tbaa !5
  %1069 = ptrtoint ptr %1067 to i64
  %1070 = ptrtoint ptr %1068 to i64
  %1071 = sub i64 %1069, %1070
  %1072 = load ptr, ptr %12, align 8, !tbaa !5
  %1073 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1072, i32 0, i32 4
  %1074 = getelementptr inbounds %struct.UT_hash_handle, ptr %1073, i32 0, i32 0
  %1075 = load ptr, ptr %1074, align 8, !tbaa !35
  %1076 = getelementptr inbounds %struct.UT_hash_table, ptr %1075, i32 0, i32 5
  store i64 %1071, ptr %1076, align 8, !tbaa !43
  %1077 = call noalias ptr @malloc(i64 noundef 512) #12
  %1078 = load ptr, ptr %12, align 8, !tbaa !5
  %1079 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1078, i32 0, i32 4
  %1080 = getelementptr inbounds %struct.UT_hash_handle, ptr %1079, i32 0, i32 0
  %1081 = load ptr, ptr %1080, align 8, !tbaa !35
  %1082 = getelementptr inbounds %struct.UT_hash_table, ptr %1081, i32 0, i32 0
  store ptr %1077, ptr %1082, align 8, !tbaa !40
  %1083 = load ptr, ptr %12, align 8, !tbaa !5
  %1084 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1083, i32 0, i32 4
  %1085 = getelementptr inbounds %struct.UT_hash_handle, ptr %1084, i32 0, i32 0
  %1086 = load ptr, ptr %1085, align 8, !tbaa !35
  %1087 = getelementptr inbounds %struct.UT_hash_table, ptr %1086, i32 0, i32 10
  store i32 -1609490463, ptr %1087, align 8, !tbaa !59
  %1088 = load ptr, ptr %12, align 8, !tbaa !5
  %1089 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1088, i32 0, i32 4
  %1090 = getelementptr inbounds %struct.UT_hash_handle, ptr %1089, i32 0, i32 0
  %1091 = load ptr, ptr %1090, align 8, !tbaa !35
  %1092 = getelementptr inbounds %struct.UT_hash_table, ptr %1091, i32 0, i32 0
  %1093 = load ptr, ptr %1092, align 8, !tbaa !40
  %1094 = icmp ne ptr %1093, null
  br i1 %1094, label %1096, label %1095

1095:                                             ; preds = %1044
  call void @exit(i32 noundef -1) #13
  unreachable

1096:                                             ; preds = %1044
  %1097 = load ptr, ptr %12, align 8, !tbaa !5
  %1098 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1097, i32 0, i32 4
  %1099 = getelementptr inbounds %struct.UT_hash_handle, ptr %1098, i32 0, i32 0
  %1100 = load ptr, ptr %1099, align 8, !tbaa !35
  %1101 = getelementptr inbounds %struct.UT_hash_table, ptr %1100, i32 0, i32 0
  %1102 = load ptr, ptr %1101, align 8, !tbaa !40
  call void @llvm.memset.p0.i64(ptr align 8 %1102, i8 0, i64 512, i1 false)
  br label %1103

1103:                                             ; preds = %1096
  br label %1104

1104:                                             ; preds = %1103
  br label %1105

1105:                                             ; preds = %1104
  br label %1106

1106:                                             ; preds = %1105
  %1107 = load ptr, ptr %12, align 8, !tbaa !5
  store ptr %1107, ptr %10, align 8, !tbaa !5
  br label %1154

1108:                                             ; preds = %1011
  %1109 = load ptr, ptr %10, align 8, !tbaa !5
  %1110 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1109, i32 0, i32 4
  %1111 = getelementptr inbounds %struct.UT_hash_handle, ptr %1110, i32 0, i32 0
  %1112 = load ptr, ptr %1111, align 8, !tbaa !35
  %1113 = load ptr, ptr %12, align 8, !tbaa !5
  %1114 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1113, i32 0, i32 4
  %1115 = getelementptr inbounds %struct.UT_hash_handle, ptr %1114, i32 0, i32 0
  store ptr %1112, ptr %1115, align 8, !tbaa !35
  br label %1116

1116:                                             ; preds = %1108
  %1117 = load ptr, ptr %12, align 8, !tbaa !5
  %1118 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1117, i32 0, i32 4
  %1119 = getelementptr inbounds %struct.UT_hash_handle, ptr %1118, i32 0, i32 2
  store ptr null, ptr %1119, align 8, !tbaa !55
  %1120 = load ptr, ptr %10, align 8, !tbaa !5
  %1121 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1120, i32 0, i32 4
  %1122 = getelementptr inbounds %struct.UT_hash_handle, ptr %1121, i32 0, i32 0
  %1123 = load ptr, ptr %1122, align 8, !tbaa !35
  %1124 = getelementptr inbounds %struct.UT_hash_table, ptr %1123, i32 0, i32 4
  %1125 = load ptr, ptr %1124, align 8, !tbaa !57
  %1126 = load ptr, ptr %10, align 8, !tbaa !5
  %1127 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1126, i32 0, i32 4
  %1128 = getelementptr inbounds %struct.UT_hash_handle, ptr %1127, i32 0, i32 0
  %1129 = load ptr, ptr %1128, align 8, !tbaa !35
  %1130 = getelementptr inbounds %struct.UT_hash_table, ptr %1129, i32 0, i32 5
  %1131 = load i64, ptr %1130, align 8, !tbaa !43
  %1132 = sub i64 0, %1131
  %1133 = getelementptr inbounds i8, ptr %1125, i64 %1132
  %1134 = load ptr, ptr %12, align 8, !tbaa !5
  %1135 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1134, i32 0, i32 4
  %1136 = getelementptr inbounds %struct.UT_hash_handle, ptr %1135, i32 0, i32 1
  store ptr %1133, ptr %1136, align 8, !tbaa !56
  %1137 = load ptr, ptr %12, align 8, !tbaa !5
  %1138 = load ptr, ptr %10, align 8, !tbaa !5
  %1139 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1138, i32 0, i32 4
  %1140 = getelementptr inbounds %struct.UT_hash_handle, ptr %1139, i32 0, i32 0
  %1141 = load ptr, ptr %1140, align 8, !tbaa !35
  %1142 = getelementptr inbounds %struct.UT_hash_table, ptr %1141, i32 0, i32 4
  %1143 = load ptr, ptr %1142, align 8, !tbaa !57
  %1144 = getelementptr inbounds %struct.UT_hash_handle, ptr %1143, i32 0, i32 2
  store ptr %1137, ptr %1144, align 8, !tbaa !60
  %1145 = load ptr, ptr %12, align 8, !tbaa !5
  %1146 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1145, i32 0, i32 4
  %1147 = load ptr, ptr %10, align 8, !tbaa !5
  %1148 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1147, i32 0, i32 4
  %1149 = getelementptr inbounds %struct.UT_hash_handle, ptr %1148, i32 0, i32 0
  %1150 = load ptr, ptr %1149, align 8, !tbaa !35
  %1151 = getelementptr inbounds %struct.UT_hash_table, ptr %1150, i32 0, i32 4
  store ptr %1146, ptr %1151, align 8, !tbaa !57
  br label %1152

1152:                                             ; preds = %1116
  br label %1153

1153:                                             ; preds = %1152
  br label %1154

1154:                                             ; preds = %1153, %1106
  br label %1155

1155:                                             ; preds = %1154
  call void @llvm.lifetime.start.p0(i64 4, ptr %25) #10
  %1156 = load ptr, ptr %10, align 8, !tbaa !5
  %1157 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1156, i32 0, i32 4
  %1158 = getelementptr inbounds %struct.UT_hash_handle, ptr %1157, i32 0, i32 0
  %1159 = load ptr, ptr %1158, align 8, !tbaa !35
  %1160 = getelementptr inbounds %struct.UT_hash_table, ptr %1159, i32 0, i32 3
  %1161 = load i32, ptr %1160, align 8, !tbaa !61
  %1162 = add i32 %1161, 1
  store i32 %1162, ptr %1160, align 8, !tbaa !61
  br label %1163

1163:                                             ; preds = %1155
  %1164 = load i32, ptr %20, align 4, !tbaa !31
  %1165 = load ptr, ptr %10, align 8, !tbaa !5
  %1166 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1165, i32 0, i32 4
  %1167 = getelementptr inbounds %struct.UT_hash_handle, ptr %1166, i32 0, i32 0
  %1168 = load ptr, ptr %1167, align 8, !tbaa !35
  %1169 = getelementptr inbounds %struct.UT_hash_table, ptr %1168, i32 0, i32 1
  %1170 = load i32, ptr %1169, align 8, !tbaa !38
  %1171 = sub i32 %1170, 1
  %1172 = and i32 %1164, %1171
  store i32 %1172, ptr %25, align 4, !tbaa !31
  br label %1173

1173:                                             ; preds = %1163
  br label %1174

1174:                                             ; preds = %1173
  br label %1175

1175:                                             ; preds = %1174
  call void @llvm.lifetime.start.p0(i64 8, ptr %26) #10
  %1176 = load ptr, ptr %10, align 8, !tbaa !5
  %1177 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1176, i32 0, i32 4
  %1178 = getelementptr inbounds %struct.UT_hash_handle, ptr %1177, i32 0, i32 0
  %1179 = load ptr, ptr %1178, align 8, !tbaa !35
  %1180 = getelementptr inbounds %struct.UT_hash_table, ptr %1179, i32 0, i32 0
  %1181 = load ptr, ptr %1180, align 8, !tbaa !40
  %1182 = load i32, ptr %25, align 4, !tbaa !31
  %1183 = zext i32 %1182 to i64
  %1184 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1181, i64 %1183
  store ptr %1184, ptr %26, align 8, !tbaa !5
  %1185 = load ptr, ptr %26, align 8, !tbaa !5
  %1186 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1185, i32 0, i32 1
  %1187 = load i32, ptr %1186, align 8, !tbaa !62
  %1188 = add i32 %1187, 1
  store i32 %1188, ptr %1186, align 8, !tbaa !62
  %1189 = load ptr, ptr %26, align 8, !tbaa !5
  %1190 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1189, i32 0, i32 0
  %1191 = load ptr, ptr %1190, align 8, !tbaa !41
  %1192 = load ptr, ptr %12, align 8, !tbaa !5
  %1193 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1192, i32 0, i32 4
  %1194 = getelementptr inbounds %struct.UT_hash_handle, ptr %1193, i32 0, i32 4
  store ptr %1191, ptr %1194, align 8, !tbaa !47
  %1195 = load ptr, ptr %12, align 8, !tbaa !5
  %1196 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1195, i32 0, i32 4
  %1197 = getelementptr inbounds %struct.UT_hash_handle, ptr %1196, i32 0, i32 3
  store ptr null, ptr %1197, align 8, !tbaa !63
  %1198 = load ptr, ptr %26, align 8, !tbaa !5
  %1199 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1198, i32 0, i32 0
  %1200 = load ptr, ptr %1199, align 8, !tbaa !41
  %1201 = icmp ne ptr %1200, null
  br i1 %1201, label %1202, label %1209

1202:                                             ; preds = %1175
  %1203 = load ptr, ptr %12, align 8, !tbaa !5
  %1204 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1203, i32 0, i32 4
  %1205 = load ptr, ptr %26, align 8, !tbaa !5
  %1206 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1205, i32 0, i32 0
  %1207 = load ptr, ptr %1206, align 8, !tbaa !41
  %1208 = getelementptr inbounds %struct.UT_hash_handle, ptr %1207, i32 0, i32 3
  store ptr %1204, ptr %1208, align 8, !tbaa !64
  br label %1209

1209:                                             ; preds = %1202, %1175
  %1210 = load ptr, ptr %12, align 8, !tbaa !5
  %1211 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1210, i32 0, i32 4
  %1212 = load ptr, ptr %26, align 8, !tbaa !5
  %1213 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1212, i32 0, i32 0
  store ptr %1211, ptr %1213, align 8, !tbaa !41
  %1214 = load ptr, ptr %26, align 8, !tbaa !5
  %1215 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1214, i32 0, i32 1
  %1216 = load i32, ptr %1215, align 8, !tbaa !62
  %1217 = load ptr, ptr %26, align 8, !tbaa !5
  %1218 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1217, i32 0, i32 2
  %1219 = load i32, ptr %1218, align 4, !tbaa !65
  %1220 = add i32 %1219, 1
  %1221 = mul i32 %1220, 10
  %1222 = icmp uge i32 %1216, %1221
  br i1 %1222, label %1223, label %1479

1223:                                             ; preds = %1209
  %1224 = load ptr, ptr %12, align 8, !tbaa !5
  %1225 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1224, i32 0, i32 4
  %1226 = getelementptr inbounds %struct.UT_hash_handle, ptr %1225, i32 0, i32 0
  %1227 = load ptr, ptr %1226, align 8, !tbaa !35
  %1228 = getelementptr inbounds %struct.UT_hash_table, ptr %1227, i32 0, i32 9
  %1229 = load i32, ptr %1228, align 4, !tbaa !66
  %1230 = icmp ne i32 %1229, 0
  br i1 %1230, label %1479, label %1231

1231:                                             ; preds = %1223
  br label %1232

1232:                                             ; preds = %1231
  call void @llvm.lifetime.start.p0(i64 4, ptr %27) #10
  call void @llvm.lifetime.start.p0(i64 4, ptr %28) #10
  call void @llvm.lifetime.start.p0(i64 8, ptr %29) #10
  call void @llvm.lifetime.start.p0(i64 8, ptr %30) #10
  call void @llvm.lifetime.start.p0(i64 8, ptr %31) #10
  call void @llvm.lifetime.start.p0(i64 8, ptr %32) #10
  %1233 = load ptr, ptr %12, align 8, !tbaa !5
  %1234 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1233, i32 0, i32 4
  %1235 = getelementptr inbounds %struct.UT_hash_handle, ptr %1234, i32 0, i32 0
  %1236 = load ptr, ptr %1235, align 8, !tbaa !35
  %1237 = getelementptr inbounds %struct.UT_hash_table, ptr %1236, i32 0, i32 1
  %1238 = load i32, ptr %1237, align 8, !tbaa !38
  %1239 = zext i32 %1238 to i64
  %1240 = mul i64 2, %1239
  %1241 = mul i64 %1240, 16
  %1242 = call noalias ptr @malloc(i64 noundef %1241) #12
  store ptr %1242, ptr %31, align 8, !tbaa !5
  %1243 = load ptr, ptr %31, align 8, !tbaa !5
  %1244 = icmp ne ptr %1243, null
  br i1 %1244, label %1246, label %1245

1245:                                             ; preds = %1232
  call void @exit(i32 noundef -1) #13
  unreachable

1246:                                             ; preds = %1232
  %1247 = load ptr, ptr %31, align 8, !tbaa !5
  %1248 = load ptr, ptr %12, align 8, !tbaa !5
  %1249 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1248, i32 0, i32 4
  %1250 = getelementptr inbounds %struct.UT_hash_handle, ptr %1249, i32 0, i32 0
  %1251 = load ptr, ptr %1250, align 8, !tbaa !35
  %1252 = getelementptr inbounds %struct.UT_hash_table, ptr %1251, i32 0, i32 1
  %1253 = load i32, ptr %1252, align 8, !tbaa !38
  %1254 = zext i32 %1253 to i64
  %1255 = mul i64 2, %1254
  %1256 = mul i64 %1255, 16
  call void @llvm.memset.p0.i64(ptr align 8 %1247, i8 0, i64 %1256, i1 false)
  %1257 = load ptr, ptr %12, align 8, !tbaa !5
  %1258 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1257, i32 0, i32 4
  %1259 = getelementptr inbounds %struct.UT_hash_handle, ptr %1258, i32 0, i32 0
  %1260 = load ptr, ptr %1259, align 8, !tbaa !35
  %1261 = getelementptr inbounds %struct.UT_hash_table, ptr %1260, i32 0, i32 3
  %1262 = load i32, ptr %1261, align 8, !tbaa !61
  %1263 = load ptr, ptr %12, align 8, !tbaa !5
  %1264 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1263, i32 0, i32 4
  %1265 = getelementptr inbounds %struct.UT_hash_handle, ptr %1264, i32 0, i32 0
  %1266 = load ptr, ptr %1265, align 8, !tbaa !35
  %1267 = getelementptr inbounds %struct.UT_hash_table, ptr %1266, i32 0, i32 2
  %1268 = load i32, ptr %1267, align 4, !tbaa !58
  %1269 = add i32 %1268, 1
  %1270 = lshr i32 %1262, %1269
  %1271 = load ptr, ptr %12, align 8, !tbaa !5
  %1272 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1271, i32 0, i32 4
  %1273 = getelementptr inbounds %struct.UT_hash_handle, ptr %1272, i32 0, i32 0
  %1274 = load ptr, ptr %1273, align 8, !tbaa !35
  %1275 = getelementptr inbounds %struct.UT_hash_table, ptr %1274, i32 0, i32 3
  %1276 = load i32, ptr %1275, align 8, !tbaa !61
  %1277 = load ptr, ptr %12, align 8, !tbaa !5
  %1278 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1277, i32 0, i32 4
  %1279 = getelementptr inbounds %struct.UT_hash_handle, ptr %1278, i32 0, i32 0
  %1280 = load ptr, ptr %1279, align 8, !tbaa !35
  %1281 = getelementptr inbounds %struct.UT_hash_table, ptr %1280, i32 0, i32 1
  %1282 = load i32, ptr %1281, align 8, !tbaa !38
  %1283 = mul i32 %1282, 2
  %1284 = sub i32 %1283, 1
  %1285 = and i32 %1276, %1284
  %1286 = icmp ne i32 %1285, 0
  %1287 = zext i1 %1286 to i64
  %1288 = select i1 %1286, i32 1, i32 0
  %1289 = add i32 %1270, %1288
  %1290 = load ptr, ptr %12, align 8, !tbaa !5
  %1291 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1290, i32 0, i32 4
  %1292 = getelementptr inbounds %struct.UT_hash_handle, ptr %1291, i32 0, i32 0
  %1293 = load ptr, ptr %1292, align 8, !tbaa !35
  %1294 = getelementptr inbounds %struct.UT_hash_table, ptr %1293, i32 0, i32 6
  store i32 %1289, ptr %1294, align 8, !tbaa !67
  %1295 = load ptr, ptr %12, align 8, !tbaa !5
  %1296 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1295, i32 0, i32 4
  %1297 = getelementptr inbounds %struct.UT_hash_handle, ptr %1296, i32 0, i32 0
  %1298 = load ptr, ptr %1297, align 8, !tbaa !35
  %1299 = getelementptr inbounds %struct.UT_hash_table, ptr %1298, i32 0, i32 7
  store i32 0, ptr %1299, align 4, !tbaa !68
  store i32 0, ptr %28, align 4, !tbaa !31
  br label %1300

1300:                                             ; preds = %1402, %1246
  %1301 = load i32, ptr %28, align 4, !tbaa !31
  %1302 = load ptr, ptr %12, align 8, !tbaa !5
  %1303 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1302, i32 0, i32 4
  %1304 = getelementptr inbounds %struct.UT_hash_handle, ptr %1303, i32 0, i32 0
  %1305 = load ptr, ptr %1304, align 8, !tbaa !35
  %1306 = getelementptr inbounds %struct.UT_hash_table, ptr %1305, i32 0, i32 1
  %1307 = load i32, ptr %1306, align 8, !tbaa !38
  %1308 = icmp ult i32 %1301, %1307
  br i1 %1308, label %1309, label %1405

1309:                                             ; preds = %1300
  %1310 = load ptr, ptr %12, align 8, !tbaa !5
  %1311 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1310, i32 0, i32 4
  %1312 = getelementptr inbounds %struct.UT_hash_handle, ptr %1311, i32 0, i32 0
  %1313 = load ptr, ptr %1312, align 8, !tbaa !35
  %1314 = getelementptr inbounds %struct.UT_hash_table, ptr %1313, i32 0, i32 0
  %1315 = load ptr, ptr %1314, align 8, !tbaa !40
  %1316 = load i32, ptr %28, align 4, !tbaa !31
  %1317 = zext i32 %1316 to i64
  %1318 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1315, i64 %1317
  %1319 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1318, i32 0, i32 0
  %1320 = load ptr, ptr %1319, align 8, !tbaa !41
  store ptr %1320, ptr %29, align 8, !tbaa !5
  br label %1321

1321:                                             ; preds = %1396, %1309
  %1322 = load ptr, ptr %29, align 8, !tbaa !5
  %1323 = icmp ne ptr %1322, null
  br i1 %1323, label %1324, label %1401

1324:                                             ; preds = %1321
  %1325 = load ptr, ptr %29, align 8, !tbaa !5
  %1326 = getelementptr inbounds %struct.UT_hash_handle, ptr %1325, i32 0, i32 4
  %1327 = load ptr, ptr %1326, align 8, !tbaa !69
  store ptr %1327, ptr %30, align 8, !tbaa !5
  br label %1328

1328:                                             ; preds = %1324
  %1329 = load ptr, ptr %29, align 8, !tbaa !5
  %1330 = getelementptr inbounds %struct.UT_hash_handle, ptr %1329, i32 0, i32 7
  %1331 = load i32, ptr %1330, align 4, !tbaa !70
  %1332 = load ptr, ptr %12, align 8, !tbaa !5
  %1333 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1332, i32 0, i32 4
  %1334 = getelementptr inbounds %struct.UT_hash_handle, ptr %1333, i32 0, i32 0
  %1335 = load ptr, ptr %1334, align 8, !tbaa !35
  %1336 = getelementptr inbounds %struct.UT_hash_table, ptr %1335, i32 0, i32 1
  %1337 = load i32, ptr %1336, align 8, !tbaa !38
  %1338 = mul i32 %1337, 2
  %1339 = sub i32 %1338, 1
  %1340 = and i32 %1331, %1339
  store i32 %1340, ptr %27, align 4, !tbaa !31
  br label %1341

1341:                                             ; preds = %1328
  br label %1342

1342:                                             ; preds = %1341
  %1343 = load ptr, ptr %31, align 8, !tbaa !5
  %1344 = load i32, ptr %27, align 4, !tbaa !31
  %1345 = zext i32 %1344 to i64
  %1346 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1343, i64 %1345
  store ptr %1346, ptr %32, align 8, !tbaa !5
  %1347 = load ptr, ptr %32, align 8, !tbaa !5
  %1348 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1347, i32 0, i32 1
  %1349 = load i32, ptr %1348, align 8, !tbaa !62
  %1350 = add i32 %1349, 1
  store i32 %1350, ptr %1348, align 8, !tbaa !62
  %1351 = load ptr, ptr %12, align 8, !tbaa !5
  %1352 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1351, i32 0, i32 4
  %1353 = getelementptr inbounds %struct.UT_hash_handle, ptr %1352, i32 0, i32 0
  %1354 = load ptr, ptr %1353, align 8, !tbaa !35
  %1355 = getelementptr inbounds %struct.UT_hash_table, ptr %1354, i32 0, i32 6
  %1356 = load i32, ptr %1355, align 8, !tbaa !67
  %1357 = icmp ugt i32 %1350, %1356
  br i1 %1357, label %1358, label %1378

1358:                                             ; preds = %1342
  %1359 = load ptr, ptr %12, align 8, !tbaa !5
  %1360 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1359, i32 0, i32 4
  %1361 = getelementptr inbounds %struct.UT_hash_handle, ptr %1360, i32 0, i32 0
  %1362 = load ptr, ptr %1361, align 8, !tbaa !35
  %1363 = getelementptr inbounds %struct.UT_hash_table, ptr %1362, i32 0, i32 7
  %1364 = load i32, ptr %1363, align 4, !tbaa !68
  %1365 = add i32 %1364, 1
  store i32 %1365, ptr %1363, align 4, !tbaa !68
  %1366 = load ptr, ptr %32, align 8, !tbaa !5
  %1367 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1366, i32 0, i32 1
  %1368 = load i32, ptr %1367, align 8, !tbaa !62
  %1369 = load ptr, ptr %12, align 8, !tbaa !5
  %1370 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1369, i32 0, i32 4
  %1371 = getelementptr inbounds %struct.UT_hash_handle, ptr %1370, i32 0, i32 0
  %1372 = load ptr, ptr %1371, align 8, !tbaa !35
  %1373 = getelementptr inbounds %struct.UT_hash_table, ptr %1372, i32 0, i32 6
  %1374 = load i32, ptr %1373, align 8, !tbaa !67
  %1375 = udiv i32 %1368, %1374
  %1376 = load ptr, ptr %32, align 8, !tbaa !5
  %1377 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1376, i32 0, i32 2
  store i32 %1375, ptr %1377, align 4, !tbaa !65
  br label %1378

1378:                                             ; preds = %1358, %1342
  %1379 = load ptr, ptr %29, align 8, !tbaa !5
  %1380 = getelementptr inbounds %struct.UT_hash_handle, ptr %1379, i32 0, i32 3
  store ptr null, ptr %1380, align 8, !tbaa !64
  %1381 = load ptr, ptr %32, align 8, !tbaa !5
  %1382 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1381, i32 0, i32 0
  %1383 = load ptr, ptr %1382, align 8, !tbaa !41
  %1384 = load ptr, ptr %29, align 8, !tbaa !5
  %1385 = getelementptr inbounds %struct.UT_hash_handle, ptr %1384, i32 0, i32 4
  store ptr %1383, ptr %1385, align 8, !tbaa !69
  %1386 = load ptr, ptr %32, align 8, !tbaa !5
  %1387 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1386, i32 0, i32 0
  %1388 = load ptr, ptr %1387, align 8, !tbaa !41
  %1389 = icmp ne ptr %1388, null
  br i1 %1389, label %1390, label %1396

1390:                                             ; preds = %1378
  %1391 = load ptr, ptr %29, align 8, !tbaa !5
  %1392 = load ptr, ptr %32, align 8, !tbaa !5
  %1393 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1392, i32 0, i32 0
  %1394 = load ptr, ptr %1393, align 8, !tbaa !41
  %1395 = getelementptr inbounds %struct.UT_hash_handle, ptr %1394, i32 0, i32 3
  store ptr %1391, ptr %1395, align 8, !tbaa !64
  br label %1396

1396:                                             ; preds = %1390, %1378
  %1397 = load ptr, ptr %29, align 8, !tbaa !5
  %1398 = load ptr, ptr %32, align 8, !tbaa !5
  %1399 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1398, i32 0, i32 0
  store ptr %1397, ptr %1399, align 8, !tbaa !41
  %1400 = load ptr, ptr %30, align 8, !tbaa !5
  store ptr %1400, ptr %29, align 8, !tbaa !5
  br label %1321, !llvm.loop !71

1401:                                             ; preds = %1321
  br label %1402

1402:                                             ; preds = %1401
  %1403 = load i32, ptr %28, align 4, !tbaa !31
  %1404 = add i32 %1403, 1
  store i32 %1404, ptr %28, align 4, !tbaa !31
  br label %1300, !llvm.loop !72

1405:                                             ; preds = %1300
  %1406 = load ptr, ptr %12, align 8, !tbaa !5
  %1407 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1406, i32 0, i32 4
  %1408 = getelementptr inbounds %struct.UT_hash_handle, ptr %1407, i32 0, i32 0
  %1409 = load ptr, ptr %1408, align 8, !tbaa !35
  %1410 = getelementptr inbounds %struct.UT_hash_table, ptr %1409, i32 0, i32 0
  %1411 = load ptr, ptr %1410, align 8, !tbaa !40
  call void @free(ptr noundef %1411) #10
  %1412 = load ptr, ptr %12, align 8, !tbaa !5
  %1413 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1412, i32 0, i32 4
  %1414 = getelementptr inbounds %struct.UT_hash_handle, ptr %1413, i32 0, i32 0
  %1415 = load ptr, ptr %1414, align 8, !tbaa !35
  %1416 = getelementptr inbounds %struct.UT_hash_table, ptr %1415, i32 0, i32 1
  %1417 = load i32, ptr %1416, align 8, !tbaa !38
  %1418 = mul i32 %1417, 2
  store i32 %1418, ptr %1416, align 8, !tbaa !38
  %1419 = load ptr, ptr %12, align 8, !tbaa !5
  %1420 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1419, i32 0, i32 4
  %1421 = getelementptr inbounds %struct.UT_hash_handle, ptr %1420, i32 0, i32 0
  %1422 = load ptr, ptr %1421, align 8, !tbaa !35
  %1423 = getelementptr inbounds %struct.UT_hash_table, ptr %1422, i32 0, i32 2
  %1424 = load i32, ptr %1423, align 4, !tbaa !58
  %1425 = add i32 %1424, 1
  store i32 %1425, ptr %1423, align 4, !tbaa !58
  %1426 = load ptr, ptr %31, align 8, !tbaa !5
  %1427 = load ptr, ptr %12, align 8, !tbaa !5
  %1428 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1427, i32 0, i32 4
  %1429 = getelementptr inbounds %struct.UT_hash_handle, ptr %1428, i32 0, i32 0
  %1430 = load ptr, ptr %1429, align 8, !tbaa !35
  %1431 = getelementptr inbounds %struct.UT_hash_table, ptr %1430, i32 0, i32 0
  store ptr %1426, ptr %1431, align 8, !tbaa !40
  %1432 = load ptr, ptr %12, align 8, !tbaa !5
  %1433 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1432, i32 0, i32 4
  %1434 = getelementptr inbounds %struct.UT_hash_handle, ptr %1433, i32 0, i32 0
  %1435 = load ptr, ptr %1434, align 8, !tbaa !35
  %1436 = getelementptr inbounds %struct.UT_hash_table, ptr %1435, i32 0, i32 7
  %1437 = load i32, ptr %1436, align 4, !tbaa !68
  %1438 = load ptr, ptr %12, align 8, !tbaa !5
  %1439 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1438, i32 0, i32 4
  %1440 = getelementptr inbounds %struct.UT_hash_handle, ptr %1439, i32 0, i32 0
  %1441 = load ptr, ptr %1440, align 8, !tbaa !35
  %1442 = getelementptr inbounds %struct.UT_hash_table, ptr %1441, i32 0, i32 3
  %1443 = load i32, ptr %1442, align 8, !tbaa !61
  %1444 = lshr i32 %1443, 1
  %1445 = icmp ugt i32 %1437, %1444
  br i1 %1445, label %1446, label %1454

1446:                                             ; preds = %1405
  %1447 = load ptr, ptr %12, align 8, !tbaa !5
  %1448 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1447, i32 0, i32 4
  %1449 = getelementptr inbounds %struct.UT_hash_handle, ptr %1448, i32 0, i32 0
  %1450 = load ptr, ptr %1449, align 8, !tbaa !35
  %1451 = getelementptr inbounds %struct.UT_hash_table, ptr %1450, i32 0, i32 8
  %1452 = load i32, ptr %1451, align 8, !tbaa !73
  %1453 = add i32 %1452, 1
  br label %1455

1454:                                             ; preds = %1405
  br label %1455

1455:                                             ; preds = %1454, %1446
  %1456 = phi i32 [ %1453, %1446 ], [ 0, %1454 ]
  %1457 = load ptr, ptr %12, align 8, !tbaa !5
  %1458 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1457, i32 0, i32 4
  %1459 = getelementptr inbounds %struct.UT_hash_handle, ptr %1458, i32 0, i32 0
  %1460 = load ptr, ptr %1459, align 8, !tbaa !35
  %1461 = getelementptr inbounds %struct.UT_hash_table, ptr %1460, i32 0, i32 8
  store i32 %1456, ptr %1461, align 8, !tbaa !73
  %1462 = load ptr, ptr %12, align 8, !tbaa !5
  %1463 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1462, i32 0, i32 4
  %1464 = getelementptr inbounds %struct.UT_hash_handle, ptr %1463, i32 0, i32 0
  %1465 = load ptr, ptr %1464, align 8, !tbaa !35
  %1466 = getelementptr inbounds %struct.UT_hash_table, ptr %1465, i32 0, i32 8
  %1467 = load i32, ptr %1466, align 8, !tbaa !73
  %1468 = icmp ugt i32 %1467, 1
  br i1 %1468, label %1469, label %1475

1469:                                             ; preds = %1455
  %1470 = load ptr, ptr %12, align 8, !tbaa !5
  %1471 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1470, i32 0, i32 4
  %1472 = getelementptr inbounds %struct.UT_hash_handle, ptr %1471, i32 0, i32 0
  %1473 = load ptr, ptr %1472, align 8, !tbaa !35
  %1474 = getelementptr inbounds %struct.UT_hash_table, ptr %1473, i32 0, i32 9
  store i32 1, ptr %1474, align 4, !tbaa !66
  br label %1475

1475:                                             ; preds = %1469, %1455
  br label %1476

1476:                                             ; preds = %1475
  call void @llvm.lifetime.end.p0(i64 8, ptr %32) #10
  call void @llvm.lifetime.end.p0(i64 8, ptr %31) #10
  call void @llvm.lifetime.end.p0(i64 8, ptr %30) #10
  call void @llvm.lifetime.end.p0(i64 8, ptr %29) #10
  call void @llvm.lifetime.end.p0(i64 4, ptr %28) #10
  call void @llvm.lifetime.end.p0(i64 4, ptr %27) #10
  br label %1477

1477:                                             ; preds = %1476
  br label %1478

1478:                                             ; preds = %1477
  br label %1479

1479:                                             ; preds = %1478, %1223, %1209
  call void @llvm.lifetime.end.p0(i64 8, ptr %26) #10
  br label %1480

1480:                                             ; preds = %1479
  br label %1481

1481:                                             ; preds = %1480
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #10
  br label %1482

1482:                                             ; preds = %1481
  br label %1483

1483:                                             ; preds = %1482
  br label %1484

1484:                                             ; preds = %1483
  br label %1485

1485:                                             ; preds = %1484
  call void @llvm.lifetime.end.p0(i64 4, ptr %20) #10
  br label %1486

1486:                                             ; preds = %1485
  br label %1487

1487:                                             ; preds = %1486
  br label %1488

1488:                                             ; preds = %1487, %581
  call void @llvm.lifetime.end.p0(i64 4, ptr %13) #10
  call void @llvm.lifetime.end.p0(i64 8, ptr %12) #10
  br label %1489

1489:                                             ; preds = %1488, %72
  %1490 = load i16, ptr %11, align 2, !tbaa !9
  %1491 = add i16 %1490, 1
  store i16 %1491, ptr %11, align 2, !tbaa !9
  br label %51, !llvm.loop !74

1492:                                             ; preds = %58
  br label %1493

1493:                                             ; preds = %1492
  call void @llvm.lifetime.start.p0(i64 4, ptr %33) #10
  call void @llvm.lifetime.start.p0(i64 4, ptr %34) #10
  call void @llvm.lifetime.start.p0(i64 4, ptr %35) #10
  call void @llvm.lifetime.start.p0(i64 4, ptr %36) #10
  call void @llvm.lifetime.start.p0(i64 4, ptr %37) #10
  call void @llvm.lifetime.start.p0(i64 4, ptr %38) #10
  call void @llvm.lifetime.start.p0(i64 8, ptr %39) #10
  call void @llvm.lifetime.start.p0(i64 8, ptr %40) #10
  call void @llvm.lifetime.start.p0(i64 8, ptr %41) #10
  call void @llvm.lifetime.start.p0(i64 8, ptr %42) #10
  call void @llvm.lifetime.start.p0(i64 8, ptr %43) #10
  %1494 = load ptr, ptr %10, align 8, !tbaa !5
  %1495 = icmp ne ptr %1494, null
  br i1 %1495, label %1496, label %1766

1496:                                             ; preds = %1493
  store i32 1, ptr %36, align 4, !tbaa !31
  store i32 1, ptr %34, align 4, !tbaa !31
  %1497 = load ptr, ptr %10, align 8, !tbaa !5
  %1498 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1497, i32 0, i32 4
  store ptr %1498, ptr %42, align 8, !tbaa !5
  br label %1499

1499:                                             ; preds = %1762, %1496
  %1500 = load i32, ptr %34, align 4, !tbaa !31
  %1501 = icmp ne i32 %1500, 0
  br i1 %1501, label %1502, label %1765

1502:                                             ; preds = %1499
  %1503 = load ptr, ptr %42, align 8, !tbaa !5
  store ptr %1503, ptr %39, align 8, !tbaa !5
  store ptr null, ptr %42, align 8, !tbaa !5
  store ptr null, ptr %43, align 8, !tbaa !5
  store i32 0, ptr %35, align 4, !tbaa !31
  br label %1504

1504:                                             ; preds = %1732, %1502
  %1505 = load ptr, ptr %39, align 8, !tbaa !5
  %1506 = icmp ne ptr %1505, null
  br i1 %1506, label %1507, label %1734

1507:                                             ; preds = %1504
  %1508 = load i32, ptr %35, align 4, !tbaa !31
  %1509 = add i32 %1508, 1
  store i32 %1509, ptr %35, align 4, !tbaa !31
  %1510 = load ptr, ptr %39, align 8, !tbaa !5
  store ptr %1510, ptr %40, align 8, !tbaa !5
  store i32 0, ptr %37, align 4, !tbaa !31
  store i32 0, ptr %33, align 4, !tbaa !31
  br label %1511

1511:                                             ; preds = %1540, %1507
  %1512 = load i32, ptr %33, align 4, !tbaa !31
  %1513 = load i32, ptr %36, align 4, !tbaa !31
  %1514 = icmp ult i32 %1512, %1513
  br i1 %1514, label %1515, label %1543

1515:                                             ; preds = %1511
  %1516 = load i32, ptr %37, align 4, !tbaa !31
  %1517 = add i32 %1516, 1
  store i32 %1517, ptr %37, align 4, !tbaa !31
  %1518 = load ptr, ptr %40, align 8, !tbaa !5
  %1519 = getelementptr inbounds %struct.UT_hash_handle, ptr %1518, i32 0, i32 2
  %1520 = load ptr, ptr %1519, align 8, !tbaa !60
  %1521 = icmp ne ptr %1520, null
  br i1 %1521, label %1522, label %1533

1522:                                             ; preds = %1515
  %1523 = load ptr, ptr %40, align 8, !tbaa !5
  %1524 = getelementptr inbounds %struct.UT_hash_handle, ptr %1523, i32 0, i32 2
  %1525 = load ptr, ptr %1524, align 8, !tbaa !60
  %1526 = load ptr, ptr %10, align 8, !tbaa !5
  %1527 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1526, i32 0, i32 4
  %1528 = getelementptr inbounds %struct.UT_hash_handle, ptr %1527, i32 0, i32 0
  %1529 = load ptr, ptr %1528, align 8, !tbaa !35
  %1530 = getelementptr inbounds %struct.UT_hash_table, ptr %1529, i32 0, i32 5
  %1531 = load i64, ptr %1530, align 8, !tbaa !43
  %1532 = getelementptr inbounds i8, ptr %1525, i64 %1531
  br label %1534

1533:                                             ; preds = %1515
  br label %1534

1534:                                             ; preds = %1533, %1522
  %1535 = phi ptr [ %1532, %1522 ], [ null, %1533 ]
  store ptr %1535, ptr %40, align 8, !tbaa !5
  %1536 = load ptr, ptr %40, align 8, !tbaa !5
  %1537 = icmp eq ptr %1536, null
  br i1 %1537, label %1538, label %1539

1538:                                             ; preds = %1534
  br label %1543

1539:                                             ; preds = %1534
  br label %1540

1540:                                             ; preds = %1539
  %1541 = load i32, ptr %33, align 4, !tbaa !31
  %1542 = add i32 %1541, 1
  store i32 %1542, ptr %33, align 4, !tbaa !31
  br label %1511, !llvm.loop !75

1543:                                             ; preds = %1538, %1511
  %1544 = load i32, ptr %36, align 4, !tbaa !31
  store i32 %1544, ptr %38, align 4, !tbaa !31
  br label %1545

1545:                                             ; preds = %1730, %1543
  %1546 = load i32, ptr %37, align 4, !tbaa !31
  %1547 = icmp ne i32 %1546, 0
  br i1 %1547, label %1556, label %1548

1548:                                             ; preds = %1545
  %1549 = load i32, ptr %38, align 4, !tbaa !31
  %1550 = icmp ne i32 %1549, 0
  br i1 %1550, label %1551, label %1554

1551:                                             ; preds = %1548
  %1552 = load ptr, ptr %40, align 8, !tbaa !5
  %1553 = icmp ne ptr %1552, null
  br label %1554

1554:                                             ; preds = %1551, %1548
  %1555 = phi i1 [ false, %1548 ], [ %1553, %1551 ]
  br label %1556

1556:                                             ; preds = %1554, %1545
  %1557 = phi i1 [ true, %1545 ], [ %1555, %1554 ]
  br i1 %1557, label %1558, label %1732

1558:                                             ; preds = %1556
  %1559 = load i32, ptr %37, align 4, !tbaa !31
  %1560 = icmp eq i32 %1559, 0
  br i1 %1560, label %1561, label %1583

1561:                                             ; preds = %1558
  %1562 = load ptr, ptr %40, align 8, !tbaa !5
  store ptr %1562, ptr %41, align 8, !tbaa !5
  %1563 = load ptr, ptr %40, align 8, !tbaa !5
  %1564 = getelementptr inbounds %struct.UT_hash_handle, ptr %1563, i32 0, i32 2
  %1565 = load ptr, ptr %1564, align 8, !tbaa !60
  %1566 = icmp ne ptr %1565, null
  br i1 %1566, label %1567, label %1578

1567:                                             ; preds = %1561
  %1568 = load ptr, ptr %40, align 8, !tbaa !5
  %1569 = getelementptr inbounds %struct.UT_hash_handle, ptr %1568, i32 0, i32 2
  %1570 = load ptr, ptr %1569, align 8, !tbaa !60
  %1571 = load ptr, ptr %10, align 8, !tbaa !5
  %1572 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1571, i32 0, i32 4
  %1573 = getelementptr inbounds %struct.UT_hash_handle, ptr %1572, i32 0, i32 0
  %1574 = load ptr, ptr %1573, align 8, !tbaa !35
  %1575 = getelementptr inbounds %struct.UT_hash_table, ptr %1574, i32 0, i32 5
  %1576 = load i64, ptr %1575, align 8, !tbaa !43
  %1577 = getelementptr inbounds i8, ptr %1570, i64 %1576
  br label %1579

1578:                                             ; preds = %1561
  br label %1579

1579:                                             ; preds = %1578, %1567
  %1580 = phi ptr [ %1577, %1567 ], [ null, %1578 ]
  store ptr %1580, ptr %40, align 8, !tbaa !5
  %1581 = load i32, ptr %38, align 4, !tbaa !31
  %1582 = add i32 %1581, -1
  store i32 %1582, ptr %38, align 4, !tbaa !31
  br label %1686

1583:                                             ; preds = %1558
  %1584 = load i32, ptr %38, align 4, !tbaa !31
  %1585 = icmp eq i32 %1584, 0
  br i1 %1585, label %1589, label %1586

1586:                                             ; preds = %1583
  %1587 = load ptr, ptr %40, align 8, !tbaa !5
  %1588 = icmp eq ptr %1587, null
  br i1 %1588, label %1589, label %1615

1589:                                             ; preds = %1586, %1583
  %1590 = load ptr, ptr %39, align 8, !tbaa !5
  store ptr %1590, ptr %41, align 8, !tbaa !5
  %1591 = load ptr, ptr %39, align 8, !tbaa !5
  %1592 = icmp ne ptr %1591, null
  br i1 %1592, label %1593, label %1612

1593:                                             ; preds = %1589
  %1594 = load ptr, ptr %39, align 8, !tbaa !5
  %1595 = getelementptr inbounds %struct.UT_hash_handle, ptr %1594, i32 0, i32 2
  %1596 = load ptr, ptr %1595, align 8, !tbaa !60
  %1597 = icmp ne ptr %1596, null
  br i1 %1597, label %1598, label %1609

1598:                                             ; preds = %1593
  %1599 = load ptr, ptr %39, align 8, !tbaa !5
  %1600 = getelementptr inbounds %struct.UT_hash_handle, ptr %1599, i32 0, i32 2
  %1601 = load ptr, ptr %1600, align 8, !tbaa !60
  %1602 = load ptr, ptr %10, align 8, !tbaa !5
  %1603 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1602, i32 0, i32 4
  %1604 = getelementptr inbounds %struct.UT_hash_handle, ptr %1603, i32 0, i32 0
  %1605 = load ptr, ptr %1604, align 8, !tbaa !35
  %1606 = getelementptr inbounds %struct.UT_hash_table, ptr %1605, i32 0, i32 5
  %1607 = load i64, ptr %1606, align 8, !tbaa !43
  %1608 = getelementptr inbounds i8, ptr %1601, i64 %1607
  br label %1610

1609:                                             ; preds = %1593
  br label %1610

1610:                                             ; preds = %1609, %1598
  %1611 = phi ptr [ %1608, %1598 ], [ null, %1609 ]
  store ptr %1611, ptr %39, align 8, !tbaa !5
  br label %1612

1612:                                             ; preds = %1610, %1589
  %1613 = load i32, ptr %37, align 4, !tbaa !31
  %1614 = add i32 %1613, -1
  store i32 %1614, ptr %37, align 4, !tbaa !31
  br label %1685

1615:                                             ; preds = %1586
  %1616 = load ptr, ptr %39, align 8, !tbaa !5
  %1617 = load ptr, ptr %10, align 8, !tbaa !5
  %1618 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1617, i32 0, i32 4
  %1619 = getelementptr inbounds %struct.UT_hash_handle, ptr %1618, i32 0, i32 0
  %1620 = load ptr, ptr %1619, align 8, !tbaa !35
  %1621 = getelementptr inbounds %struct.UT_hash_table, ptr %1620, i32 0, i32 5
  %1622 = load i64, ptr %1621, align 8, !tbaa !43
  %1623 = sub i64 0, %1622
  %1624 = getelementptr inbounds i8, ptr %1616, i64 %1623
  %1625 = load ptr, ptr %40, align 8, !tbaa !5
  %1626 = load ptr, ptr %10, align 8, !tbaa !5
  %1627 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1626, i32 0, i32 4
  %1628 = getelementptr inbounds %struct.UT_hash_handle, ptr %1627, i32 0, i32 0
  %1629 = load ptr, ptr %1628, align 8, !tbaa !35
  %1630 = getelementptr inbounds %struct.UT_hash_table, ptr %1629, i32 0, i32 5
  %1631 = load i64, ptr %1630, align 8, !tbaa !43
  %1632 = sub i64 0, %1631
  %1633 = getelementptr inbounds i8, ptr %1625, i64 %1632
  %1634 = call i32 @gpos_cursive_by_from_id(ptr noundef %1624, ptr noundef %1633)
  %1635 = icmp sle i32 %1634, 0
  br i1 %1635, label %1636, label %1662

1636:                                             ; preds = %1615
  %1637 = load ptr, ptr %39, align 8, !tbaa !5
  store ptr %1637, ptr %41, align 8, !tbaa !5
  %1638 = load ptr, ptr %39, align 8, !tbaa !5
  %1639 = icmp ne ptr %1638, null
  br i1 %1639, label %1640, label %1659

1640:                                             ; preds = %1636
  %1641 = load ptr, ptr %39, align 8, !tbaa !5
  %1642 = getelementptr inbounds %struct.UT_hash_handle, ptr %1641, i32 0, i32 2
  %1643 = load ptr, ptr %1642, align 8, !tbaa !60
  %1644 = icmp ne ptr %1643, null
  br i1 %1644, label %1645, label %1656

1645:                                             ; preds = %1640
  %1646 = load ptr, ptr %39, align 8, !tbaa !5
  %1647 = getelementptr inbounds %struct.UT_hash_handle, ptr %1646, i32 0, i32 2
  %1648 = load ptr, ptr %1647, align 8, !tbaa !60
  %1649 = load ptr, ptr %10, align 8, !tbaa !5
  %1650 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1649, i32 0, i32 4
  %1651 = getelementptr inbounds %struct.UT_hash_handle, ptr %1650, i32 0, i32 0
  %1652 = load ptr, ptr %1651, align 8, !tbaa !35
  %1653 = getelementptr inbounds %struct.UT_hash_table, ptr %1652, i32 0, i32 5
  %1654 = load i64, ptr %1653, align 8, !tbaa !43
  %1655 = getelementptr inbounds i8, ptr %1648, i64 %1654
  br label %1657

1656:                                             ; preds = %1640
  br label %1657

1657:                                             ; preds = %1656, %1645
  %1658 = phi ptr [ %1655, %1645 ], [ null, %1656 ]
  store ptr %1658, ptr %39, align 8, !tbaa !5
  br label %1659

1659:                                             ; preds = %1657, %1636
  %1660 = load i32, ptr %37, align 4, !tbaa !31
  %1661 = add i32 %1660, -1
  store i32 %1661, ptr %37, align 4, !tbaa !31
  br label %1684

1662:                                             ; preds = %1615
  %1663 = load ptr, ptr %40, align 8, !tbaa !5
  store ptr %1663, ptr %41, align 8, !tbaa !5
  %1664 = load ptr, ptr %40, align 8, !tbaa !5
  %1665 = getelementptr inbounds %struct.UT_hash_handle, ptr %1664, i32 0, i32 2
  %1666 = load ptr, ptr %1665, align 8, !tbaa !60
  %1667 = icmp ne ptr %1666, null
  br i1 %1667, label %1668, label %1679

1668:                                             ; preds = %1662
  %1669 = load ptr, ptr %40, align 8, !tbaa !5
  %1670 = getelementptr inbounds %struct.UT_hash_handle, ptr %1669, i32 0, i32 2
  %1671 = load ptr, ptr %1670, align 8, !tbaa !60
  %1672 = load ptr, ptr %10, align 8, !tbaa !5
  %1673 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1672, i32 0, i32 4
  %1674 = getelementptr inbounds %struct.UT_hash_handle, ptr %1673, i32 0, i32 0
  %1675 = load ptr, ptr %1674, align 8, !tbaa !35
  %1676 = getelementptr inbounds %struct.UT_hash_table, ptr %1675, i32 0, i32 5
  %1677 = load i64, ptr %1676, align 8, !tbaa !43
  %1678 = getelementptr inbounds i8, ptr %1671, i64 %1677
  br label %1680

1679:                                             ; preds = %1662
  br label %1680

1680:                                             ; preds = %1679, %1668
  %1681 = phi ptr [ %1678, %1668 ], [ null, %1679 ]
  store ptr %1681, ptr %40, align 8, !tbaa !5
  %1682 = load i32, ptr %38, align 4, !tbaa !31
  %1683 = add i32 %1682, -1
  store i32 %1683, ptr %38, align 4, !tbaa !31
  br label %1684

1684:                                             ; preds = %1680, %1659
  br label %1685

1685:                                             ; preds = %1684, %1612
  br label %1686

1686:                                             ; preds = %1685, %1579
  %1687 = load ptr, ptr %43, align 8, !tbaa !5
  %1688 = icmp ne ptr %1687, null
  br i1 %1688, label %1689, label %1707

1689:                                             ; preds = %1686
  %1690 = load ptr, ptr %41, align 8, !tbaa !5
  %1691 = icmp ne ptr %1690, null
  br i1 %1691, label %1692, label %1702

1692:                                             ; preds = %1689
  %1693 = load ptr, ptr %41, align 8, !tbaa !5
  %1694 = load ptr, ptr %10, align 8, !tbaa !5
  %1695 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1694, i32 0, i32 4
  %1696 = getelementptr inbounds %struct.UT_hash_handle, ptr %1695, i32 0, i32 0
  %1697 = load ptr, ptr %1696, align 8, !tbaa !35
  %1698 = getelementptr inbounds %struct.UT_hash_table, ptr %1697, i32 0, i32 5
  %1699 = load i64, ptr %1698, align 8, !tbaa !43
  %1700 = sub i64 0, %1699
  %1701 = getelementptr inbounds i8, ptr %1693, i64 %1700
  br label %1703

1702:                                             ; preds = %1689
  br label %1703

1703:                                             ; preds = %1702, %1692
  %1704 = phi ptr [ %1701, %1692 ], [ null, %1702 ]
  %1705 = load ptr, ptr %43, align 8, !tbaa !5
  %1706 = getelementptr inbounds %struct.UT_hash_handle, ptr %1705, i32 0, i32 2
  store ptr %1704, ptr %1706, align 8, !tbaa !60
  br label %1709

1707:                                             ; preds = %1686
  %1708 = load ptr, ptr %41, align 8, !tbaa !5
  store ptr %1708, ptr %42, align 8, !tbaa !5
  br label %1709

1709:                                             ; preds = %1707, %1703
  %1710 = load ptr, ptr %41, align 8, !tbaa !5
  %1711 = icmp ne ptr %1710, null
  br i1 %1711, label %1712, label %1730

1712:                                             ; preds = %1709
  %1713 = load ptr, ptr %43, align 8, !tbaa !5
  %1714 = icmp ne ptr %1713, null
  br i1 %1714, label %1715, label %1725

1715:                                             ; preds = %1712
  %1716 = load ptr, ptr %43, align 8, !tbaa !5
  %1717 = load ptr, ptr %10, align 8, !tbaa !5
  %1718 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1717, i32 0, i32 4
  %1719 = getelementptr inbounds %struct.UT_hash_handle, ptr %1718, i32 0, i32 0
  %1720 = load ptr, ptr %1719, align 8, !tbaa !35
  %1721 = getelementptr inbounds %struct.UT_hash_table, ptr %1720, i32 0, i32 5
  %1722 = load i64, ptr %1721, align 8, !tbaa !43
  %1723 = sub i64 0, %1722
  %1724 = getelementptr inbounds i8, ptr %1716, i64 %1723
  br label %1726

1725:                                             ; preds = %1712
  br label %1726

1726:                                             ; preds = %1725, %1715
  %1727 = phi ptr [ %1724, %1715 ], [ null, %1725 ]
  %1728 = load ptr, ptr %41, align 8, !tbaa !5
  %1729 = getelementptr inbounds %struct.UT_hash_handle, ptr %1728, i32 0, i32 1
  store ptr %1727, ptr %1729, align 8, !tbaa !76
  br label %1730

1730:                                             ; preds = %1726, %1709
  %1731 = load ptr, ptr %41, align 8, !tbaa !5
  store ptr %1731, ptr %43, align 8, !tbaa !5
  br label %1545, !llvm.loop !77

1732:                                             ; preds = %1556
  %1733 = load ptr, ptr %40, align 8, !tbaa !5
  store ptr %1733, ptr %39, align 8, !tbaa !5
  br label %1504, !llvm.loop !78

1734:                                             ; preds = %1504
  %1735 = load ptr, ptr %43, align 8, !tbaa !5
  %1736 = icmp ne ptr %1735, null
  br i1 %1736, label %1737, label %1740

1737:                                             ; preds = %1734
  %1738 = load ptr, ptr %43, align 8, !tbaa !5
  %1739 = getelementptr inbounds %struct.UT_hash_handle, ptr %1738, i32 0, i32 2
  store ptr null, ptr %1739, align 8, !tbaa !60
  br label %1740

1740:                                             ; preds = %1737, %1734
  %1741 = load i32, ptr %35, align 4, !tbaa !31
  %1742 = icmp ule i32 %1741, 1
  br i1 %1742, label %1743, label %1762

1743:                                             ; preds = %1740
  store i32 0, ptr %34, align 4, !tbaa !31
  %1744 = load ptr, ptr %43, align 8, !tbaa !5
  %1745 = load ptr, ptr %10, align 8, !tbaa !5
  %1746 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1745, i32 0, i32 4
  %1747 = getelementptr inbounds %struct.UT_hash_handle, ptr %1746, i32 0, i32 0
  %1748 = load ptr, ptr %1747, align 8, !tbaa !35
  %1749 = getelementptr inbounds %struct.UT_hash_table, ptr %1748, i32 0, i32 4
  store ptr %1744, ptr %1749, align 8, !tbaa !57
  br label %1750

1750:                                             ; preds = %1743
  %1751 = load ptr, ptr %42, align 8, !tbaa !5
  %1752 = load ptr, ptr %10, align 8, !tbaa !5
  %1753 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1752, i32 0, i32 4
  %1754 = getelementptr inbounds %struct.UT_hash_handle, ptr %1753, i32 0, i32 0
  %1755 = load ptr, ptr %1754, align 8, !tbaa !35
  %1756 = getelementptr inbounds %struct.UT_hash_table, ptr %1755, i32 0, i32 5
  %1757 = load i64, ptr %1756, align 8, !tbaa !43
  %1758 = sub i64 0, %1757
  %1759 = getelementptr inbounds i8, ptr %1751, i64 %1758
  store ptr %1759, ptr %10, align 8, !tbaa !5
  br label %1760

1760:                                             ; preds = %1750
  br label %1761

1761:                                             ; preds = %1760
  br label %1762

1762:                                             ; preds = %1761, %1740
  %1763 = load i32, ptr %36, align 4, !tbaa !31
  %1764 = mul i32 %1763, 2
  store i32 %1764, ptr %36, align 4, !tbaa !31
  br label %1499, !llvm.loop !79

1765:                                             ; preds = %1499
  br label %1766

1766:                                             ; preds = %1765, %1493
  call void @llvm.lifetime.end.p0(i64 8, ptr %43) #10
  call void @llvm.lifetime.end.p0(i64 8, ptr %42) #10
  call void @llvm.lifetime.end.p0(i64 8, ptr %41) #10
  call void @llvm.lifetime.end.p0(i64 8, ptr %40) #10
  call void @llvm.lifetime.end.p0(i64 8, ptr %39) #10
  call void @llvm.lifetime.end.p0(i64 4, ptr %38) #10
  call void @llvm.lifetime.end.p0(i64 4, ptr %37) #10
  call void @llvm.lifetime.end.p0(i64 4, ptr %36) #10
  call void @llvm.lifetime.end.p0(i64 4, ptr %35) #10
  call void @llvm.lifetime.end.p0(i64 4, ptr %34) #10
  call void @llvm.lifetime.end.p0(i64 4, ptr %33) #10
  br label %1767

1767:                                             ; preds = %1766
  br label %1768

1768:                                             ; preds = %1767
  %1769 = load ptr, ptr getelementptr inbounds (%struct.__caryll_vectorinterface_subtable_gpos_cursive, ptr @iSubtable_gpos_cursive, i32 0, i32 12), align 8, !tbaa !80
  %1770 = load ptr, ptr %9, align 8, !tbaa !5
  call void %1769(ptr noundef %1770)
  call void @llvm.lifetime.start.p0(i64 8, ptr %44) #10
  call void @llvm.lifetime.start.p0(i64 8, ptr %45) #10
  %1771 = load ptr, ptr %10, align 8, !tbaa !5
  store ptr %1771, ptr %44, align 8, !tbaa !5
  %1772 = load ptr, ptr %10, align 8, !tbaa !5
  %1773 = icmp ne ptr %1772, null
  br i1 %1773, label %1774, label %1779

1774:                                             ; preds = %1768
  %1775 = load ptr, ptr %10, align 8, !tbaa !5
  %1776 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1775, i32 0, i32 4
  %1777 = getelementptr inbounds %struct.UT_hash_handle, ptr %1776, i32 0, i32 2
  %1778 = load ptr, ptr %1777, align 8, !tbaa !55
  br label %1780

1779:                                             ; preds = %1768
  br label %1780

1780:                                             ; preds = %1779, %1774
  %1781 = phi ptr [ %1778, %1774 ], [ null, %1779 ]
  store ptr %1781, ptr %45, align 8, !tbaa !5
  br label %1782

1782:                                             ; preds = %1996, %1780
  %1783 = load ptr, ptr %44, align 8, !tbaa !5
  %1784 = icmp ne ptr %1783, null
  br i1 %1784, label %1785, label %1998

1785:                                             ; preds = %1782
  %1786 = load ptr, ptr getelementptr inbounds (%struct.__caryll_vectorinterface_subtable_gpos_cursive, ptr @iSubtable_gpos_cursive, i32 0, i32 13), align 8, !tbaa !82
  %1787 = load ptr, ptr %9, align 8, !tbaa !5
  %1788 = getelementptr inbounds %struct.otl_GposCursiveEntry, ptr %46, i32 0, i32 0
  %1789 = load ptr, ptr getelementptr inbounds (%struct.otfcc_HandlePackage, ptr @otfcc_iHandle, i32 0, i32 10), align 8, !tbaa !83
  %1790 = load ptr, ptr %44, align 8, !tbaa !5
  %1791 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1790, i32 0, i32 0
  %1792 = load i32, ptr %1791, align 8, !tbaa !49
  %1793 = trunc i32 %1792 to i16
  %1794 = load ptr, ptr %44, align 8, !tbaa !5
  %1795 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1794, i32 0, i32 1
  %1796 = load ptr, ptr %1795, align 8, !tbaa !50
  %1797 = call { i64, ptr } %1789(i16 noundef zeroext %1793, ptr noundef %1796)
  %1798 = getelementptr inbounds { i64, ptr }, ptr %1788, i32 0, i32 0
  %1799 = extractvalue { i64, ptr } %1797, 0
  store i64 %1799, ptr %1798, align 8
  %1800 = getelementptr inbounds { i64, ptr }, ptr %1788, i32 0, i32 1
  %1801 = extractvalue { i64, ptr } %1797, 1
  store ptr %1801, ptr %1800, align 8
  %1802 = getelementptr inbounds %struct.otl_GposCursiveEntry, ptr %46, i32 0, i32 1
  %1803 = load ptr, ptr %44, align 8, !tbaa !5
  %1804 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1803, i32 0, i32 2
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %1802, ptr align 8 %1804, i64 24, i1 false), !tbaa.struct !51
  %1805 = getelementptr inbounds %struct.otl_GposCursiveEntry, ptr %46, i32 0, i32 2
  %1806 = load ptr, ptr %44, align 8, !tbaa !5
  %1807 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1806, i32 0, i32 3
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %1805, ptr align 8 %1807, i64 24, i1 false), !tbaa.struct !51
  call void %1786(ptr noundef %1787, ptr noundef byval(%struct.otl_GposCursiveEntry) align 8 %46)
  %1808 = load ptr, ptr %44, align 8, !tbaa !5
  %1809 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1808, i32 0, i32 1
  %1810 = load ptr, ptr %1809, align 8, !tbaa !50
  call void @sdsfree(ptr noundef %1810)
  br label %1811

1811:                                             ; preds = %1785
  call void @llvm.lifetime.start.p0(i64 8, ptr %47) #10
  %1812 = load ptr, ptr %44, align 8, !tbaa !5
  %1813 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1812, i32 0, i32 4
  store ptr %1813, ptr %47, align 8, !tbaa !5
  %1814 = load ptr, ptr %47, align 8, !tbaa !5
  %1815 = getelementptr inbounds %struct.UT_hash_handle, ptr %1814, i32 0, i32 1
  %1816 = load ptr, ptr %1815, align 8, !tbaa !76
  %1817 = icmp eq ptr %1816, null
  br i1 %1817, label %1818, label %1834

1818:                                             ; preds = %1811
  %1819 = load ptr, ptr %47, align 8, !tbaa !5
  %1820 = getelementptr inbounds %struct.UT_hash_handle, ptr %1819, i32 0, i32 2
  %1821 = load ptr, ptr %1820, align 8, !tbaa !60
  %1822 = icmp eq ptr %1821, null
  br i1 %1822, label %1823, label %1834

1823:                                             ; preds = %1818
  %1824 = load ptr, ptr %10, align 8, !tbaa !5
  %1825 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1824, i32 0, i32 4
  %1826 = getelementptr inbounds %struct.UT_hash_handle, ptr %1825, i32 0, i32 0
  %1827 = load ptr, ptr %1826, align 8, !tbaa !35
  %1828 = getelementptr inbounds %struct.UT_hash_table, ptr %1827, i32 0, i32 0
  %1829 = load ptr, ptr %1828, align 8, !tbaa !40
  call void @free(ptr noundef %1829) #10
  %1830 = load ptr, ptr %10, align 8, !tbaa !5
  %1831 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1830, i32 0, i32 4
  %1832 = getelementptr inbounds %struct.UT_hash_handle, ptr %1831, i32 0, i32 0
  %1833 = load ptr, ptr %1832, align 8, !tbaa !35
  call void @free(ptr noundef %1833) #10
  store ptr null, ptr %10, align 8, !tbaa !5
  br label %1982

1834:                                             ; preds = %1818, %1811
  call void @llvm.lifetime.start.p0(i64 4, ptr %48) #10
  %1835 = load ptr, ptr %47, align 8, !tbaa !5
  %1836 = load ptr, ptr %10, align 8, !tbaa !5
  %1837 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1836, i32 0, i32 4
  %1838 = getelementptr inbounds %struct.UT_hash_handle, ptr %1837, i32 0, i32 0
  %1839 = load ptr, ptr %1838, align 8, !tbaa !35
  %1840 = getelementptr inbounds %struct.UT_hash_table, ptr %1839, i32 0, i32 4
  %1841 = load ptr, ptr %1840, align 8, !tbaa !57
  %1842 = icmp eq ptr %1835, %1841
  br i1 %1842, label %1843, label %1859

1843:                                             ; preds = %1834
  %1844 = load ptr, ptr %47, align 8, !tbaa !5
  %1845 = getelementptr inbounds %struct.UT_hash_handle, ptr %1844, i32 0, i32 1
  %1846 = load ptr, ptr %1845, align 8, !tbaa !76
  %1847 = load ptr, ptr %10, align 8, !tbaa !5
  %1848 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1847, i32 0, i32 4
  %1849 = getelementptr inbounds %struct.UT_hash_handle, ptr %1848, i32 0, i32 0
  %1850 = load ptr, ptr %1849, align 8, !tbaa !35
  %1851 = getelementptr inbounds %struct.UT_hash_table, ptr %1850, i32 0, i32 5
  %1852 = load i64, ptr %1851, align 8, !tbaa !43
  %1853 = getelementptr inbounds i8, ptr %1846, i64 %1852
  %1854 = load ptr, ptr %10, align 8, !tbaa !5
  %1855 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1854, i32 0, i32 4
  %1856 = getelementptr inbounds %struct.UT_hash_handle, ptr %1855, i32 0, i32 0
  %1857 = load ptr, ptr %1856, align 8, !tbaa !35
  %1858 = getelementptr inbounds %struct.UT_hash_table, ptr %1857, i32 0, i32 4
  store ptr %1853, ptr %1858, align 8, !tbaa !57
  br label %1859

1859:                                             ; preds = %1843, %1834
  %1860 = load ptr, ptr %47, align 8, !tbaa !5
  %1861 = getelementptr inbounds %struct.UT_hash_handle, ptr %1860, i32 0, i32 1
  %1862 = load ptr, ptr %1861, align 8, !tbaa !76
  %1863 = icmp ne ptr %1862, null
  br i1 %1863, label %1864, label %1879

1864:                                             ; preds = %1859
  %1865 = load ptr, ptr %47, align 8, !tbaa !5
  %1866 = getelementptr inbounds %struct.UT_hash_handle, ptr %1865, i32 0, i32 2
  %1867 = load ptr, ptr %1866, align 8, !tbaa !60
  %1868 = load ptr, ptr %47, align 8, !tbaa !5
  %1869 = getelementptr inbounds %struct.UT_hash_handle, ptr %1868, i32 0, i32 1
  %1870 = load ptr, ptr %1869, align 8, !tbaa !76
  %1871 = load ptr, ptr %10, align 8, !tbaa !5
  %1872 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1871, i32 0, i32 4
  %1873 = getelementptr inbounds %struct.UT_hash_handle, ptr %1872, i32 0, i32 0
  %1874 = load ptr, ptr %1873, align 8, !tbaa !35
  %1875 = getelementptr inbounds %struct.UT_hash_table, ptr %1874, i32 0, i32 5
  %1876 = load i64, ptr %1875, align 8, !tbaa !43
  %1877 = getelementptr inbounds i8, ptr %1870, i64 %1876
  %1878 = getelementptr inbounds %struct.UT_hash_handle, ptr %1877, i32 0, i32 2
  store ptr %1867, ptr %1878, align 8, !tbaa !60
  br label %1886

1879:                                             ; preds = %1859
  br label %1880

1880:                                             ; preds = %1879
  %1881 = load ptr, ptr %47, align 8, !tbaa !5
  %1882 = getelementptr inbounds %struct.UT_hash_handle, ptr %1881, i32 0, i32 2
  %1883 = load ptr, ptr %1882, align 8, !tbaa !60
  store ptr %1883, ptr %10, align 8, !tbaa !5
  br label %1884

1884:                                             ; preds = %1880
  br label %1885

1885:                                             ; preds = %1884
  br label %1886

1886:                                             ; preds = %1885, %1864
  %1887 = load ptr, ptr %47, align 8, !tbaa !5
  %1888 = getelementptr inbounds %struct.UT_hash_handle, ptr %1887, i32 0, i32 2
  %1889 = load ptr, ptr %1888, align 8, !tbaa !60
  %1890 = icmp ne ptr %1889, null
  br i1 %1890, label %1891, label %1906

1891:                                             ; preds = %1886
  %1892 = load ptr, ptr %47, align 8, !tbaa !5
  %1893 = getelementptr inbounds %struct.UT_hash_handle, ptr %1892, i32 0, i32 1
  %1894 = load ptr, ptr %1893, align 8, !tbaa !76
  %1895 = load ptr, ptr %47, align 8, !tbaa !5
  %1896 = getelementptr inbounds %struct.UT_hash_handle, ptr %1895, i32 0, i32 2
  %1897 = load ptr, ptr %1896, align 8, !tbaa !60
  %1898 = load ptr, ptr %10, align 8, !tbaa !5
  %1899 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1898, i32 0, i32 4
  %1900 = getelementptr inbounds %struct.UT_hash_handle, ptr %1899, i32 0, i32 0
  %1901 = load ptr, ptr %1900, align 8, !tbaa !35
  %1902 = getelementptr inbounds %struct.UT_hash_table, ptr %1901, i32 0, i32 5
  %1903 = load i64, ptr %1902, align 8, !tbaa !43
  %1904 = getelementptr inbounds i8, ptr %1897, i64 %1903
  %1905 = getelementptr inbounds %struct.UT_hash_handle, ptr %1904, i32 0, i32 1
  store ptr %1894, ptr %1905, align 8, !tbaa !76
  br label %1906

1906:                                             ; preds = %1891, %1886
  br label %1907

1907:                                             ; preds = %1906
  %1908 = load ptr, ptr %47, align 8, !tbaa !5
  %1909 = getelementptr inbounds %struct.UT_hash_handle, ptr %1908, i32 0, i32 7
  %1910 = load i32, ptr %1909, align 4, !tbaa !70
  %1911 = load ptr, ptr %10, align 8, !tbaa !5
  %1912 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1911, i32 0, i32 4
  %1913 = getelementptr inbounds %struct.UT_hash_handle, ptr %1912, i32 0, i32 0
  %1914 = load ptr, ptr %1913, align 8, !tbaa !35
  %1915 = getelementptr inbounds %struct.UT_hash_table, ptr %1914, i32 0, i32 1
  %1916 = load i32, ptr %1915, align 8, !tbaa !38
  %1917 = sub i32 %1916, 1
  %1918 = and i32 %1910, %1917
  store i32 %1918, ptr %48, align 4, !tbaa !31
  br label %1919

1919:                                             ; preds = %1907
  br label %1920

1920:                                             ; preds = %1919
  br label %1921

1921:                                             ; preds = %1920
  call void @llvm.lifetime.start.p0(i64 8, ptr %49) #10
  %1922 = load ptr, ptr %10, align 8, !tbaa !5
  %1923 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1922, i32 0, i32 4
  %1924 = getelementptr inbounds %struct.UT_hash_handle, ptr %1923, i32 0, i32 0
  %1925 = load ptr, ptr %1924, align 8, !tbaa !35
  %1926 = getelementptr inbounds %struct.UT_hash_table, ptr %1925, i32 0, i32 0
  %1927 = load ptr, ptr %1926, align 8, !tbaa !40
  %1928 = load i32, ptr %48, align 4, !tbaa !31
  %1929 = zext i32 %1928 to i64
  %1930 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1927, i64 %1929
  store ptr %1930, ptr %49, align 8, !tbaa !5
  %1931 = load ptr, ptr %49, align 8, !tbaa !5
  %1932 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1931, i32 0, i32 1
  %1933 = load i32, ptr %1932, align 8, !tbaa !62
  %1934 = add i32 %1933, -1
  store i32 %1934, ptr %1932, align 8, !tbaa !62
  %1935 = load ptr, ptr %49, align 8, !tbaa !5
  %1936 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1935, i32 0, i32 0
  %1937 = load ptr, ptr %1936, align 8, !tbaa !41
  %1938 = load ptr, ptr %47, align 8, !tbaa !5
  %1939 = icmp eq ptr %1937, %1938
  br i1 %1939, label %1940, label %1946

1940:                                             ; preds = %1921
  %1941 = load ptr, ptr %47, align 8, !tbaa !5
  %1942 = getelementptr inbounds %struct.UT_hash_handle, ptr %1941, i32 0, i32 4
  %1943 = load ptr, ptr %1942, align 8, !tbaa !69
  %1944 = load ptr, ptr %49, align 8, !tbaa !5
  %1945 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1944, i32 0, i32 0
  store ptr %1943, ptr %1945, align 8, !tbaa !41
  br label %1946

1946:                                             ; preds = %1940, %1921
  %1947 = load ptr, ptr %47, align 8, !tbaa !5
  %1948 = getelementptr inbounds %struct.UT_hash_handle, ptr %1947, i32 0, i32 3
  %1949 = load ptr, ptr %1948, align 8, !tbaa !64
  %1950 = icmp ne ptr %1949, null
  br i1 %1950, label %1951, label %1959

1951:                                             ; preds = %1946
  %1952 = load ptr, ptr %47, align 8, !tbaa !5
  %1953 = getelementptr inbounds %struct.UT_hash_handle, ptr %1952, i32 0, i32 4
  %1954 = load ptr, ptr %1953, align 8, !tbaa !69
  %1955 = load ptr, ptr %47, align 8, !tbaa !5
  %1956 = getelementptr inbounds %struct.UT_hash_handle, ptr %1955, i32 0, i32 3
  %1957 = load ptr, ptr %1956, align 8, !tbaa !64
  %1958 = getelementptr inbounds %struct.UT_hash_handle, ptr %1957, i32 0, i32 4
  store ptr %1954, ptr %1958, align 8, !tbaa !69
  br label %1959

1959:                                             ; preds = %1951, %1946
  %1960 = load ptr, ptr %47, align 8, !tbaa !5
  %1961 = getelementptr inbounds %struct.UT_hash_handle, ptr %1960, i32 0, i32 4
  %1962 = load ptr, ptr %1961, align 8, !tbaa !69
  %1963 = icmp ne ptr %1962, null
  br i1 %1963, label %1964, label %1972

1964:                                             ; preds = %1959
  %1965 = load ptr, ptr %47, align 8, !tbaa !5
  %1966 = getelementptr inbounds %struct.UT_hash_handle, ptr %1965, i32 0, i32 3
  %1967 = load ptr, ptr %1966, align 8, !tbaa !64
  %1968 = load ptr, ptr %47, align 8, !tbaa !5
  %1969 = getelementptr inbounds %struct.UT_hash_handle, ptr %1968, i32 0, i32 4
  %1970 = load ptr, ptr %1969, align 8, !tbaa !69
  %1971 = getelementptr inbounds %struct.UT_hash_handle, ptr %1970, i32 0, i32 3
  store ptr %1967, ptr %1971, align 8, !tbaa !64
  br label %1972

1972:                                             ; preds = %1964, %1959
  call void @llvm.lifetime.end.p0(i64 8, ptr %49) #10
  br label %1973

1973:                                             ; preds = %1972
  br label %1974

1974:                                             ; preds = %1973
  %1975 = load ptr, ptr %10, align 8, !tbaa !5
  %1976 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1975, i32 0, i32 4
  %1977 = getelementptr inbounds %struct.UT_hash_handle, ptr %1976, i32 0, i32 0
  %1978 = load ptr, ptr %1977, align 8, !tbaa !35
  %1979 = getelementptr inbounds %struct.UT_hash_table, ptr %1978, i32 0, i32 3
  %1980 = load i32, ptr %1979, align 8, !tbaa !61
  %1981 = add i32 %1980, -1
  store i32 %1981, ptr %1979, align 8, !tbaa !61
  call void @llvm.lifetime.end.p0(i64 4, ptr %48) #10
  br label %1982

1982:                                             ; preds = %1974, %1823
  call void @llvm.lifetime.end.p0(i64 8, ptr %47) #10
  br label %1983

1983:                                             ; preds = %1982
  br label %1984

1984:                                             ; preds = %1983
  %1985 = load ptr, ptr %44, align 8, !tbaa !5
  call void @free(ptr noundef %1985) #10
  store ptr null, ptr %44, align 8, !tbaa !5
  br label %1986

1986:                                             ; preds = %1984
  %1987 = load ptr, ptr %45, align 8, !tbaa !5
  store ptr %1987, ptr %44, align 8, !tbaa !5
  %1988 = load ptr, ptr %45, align 8, !tbaa !5
  %1989 = icmp ne ptr %1988, null
  br i1 %1989, label %1990, label %1995

1990:                                             ; preds = %1986
  %1991 = load ptr, ptr %45, align 8, !tbaa !5
  %1992 = getelementptr inbounds %struct.gpos_cursive_hash, ptr %1991, i32 0, i32 4
  %1993 = getelementptr inbounds %struct.UT_hash_handle, ptr %1992, i32 0, i32 2
  %1994 = load ptr, ptr %1993, align 8, !tbaa !55
  br label %1996

1995:                                             ; preds = %1986
  br label %1996

1996:                                             ; preds = %1995, %1990
  %1997 = phi ptr [ %1994, %1990 ], [ null, %1995 ]
  store ptr %1997, ptr %45, align 8, !tbaa !5
  br label %1782, !llvm.loop !85

1998:                                             ; preds = %1782
  %1999 = load ptr, ptr %9, align 8, !tbaa !5
  %2000 = getelementptr inbounds %struct.subtable_gpos_cursive, ptr %1999, i32 0, i32 0
  %2001 = load i64, ptr %2000, align 8, !tbaa !11
  %2002 = icmp eq i64 %2001, 0
  call void @llvm.lifetime.end.p0(i64 8, ptr %45) #10
  call void @llvm.lifetime.end.p0(i64 8, ptr %44) #10
  call void @llvm.lifetime.end.p0(i64 8, ptr %10) #10
  call void @llvm.lifetime.end.p0(i64 8, ptr %9) #10
  ret i1 %2002
}

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

declare ptr @sdscatprintf(ptr noundef, ptr noundef, ...) #2

declare ptr @sdsempty() #2

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

; Function Attrs: nounwind willreturn memory(read)
declare i32 @memcmp(ptr noundef, ptr noundef, i64 noundef) #3

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

declare ptr @sdsdup(ptr noundef) #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) #5

; Function Attrs: nounwind allocsize(0)
declare noalias ptr @malloc(i64 noundef) #6

; Function Attrs: noreturn nounwind
declare void @exit(i32 noundef) #7

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

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

; Function Attrs: nounwind uwtable
declare hidden i32 @gpos_cursive_by_from_id(ptr noundef, ptr noundef) #0

declare void @sdsfree(ptr noundef) #2

attributes #0 = { 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 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
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 willreturn memory(read) "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 = { 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 #5 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #6 = { nounwind allocsize(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 #7 = { noreturn 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 #8 = { nocallback nofree nounwind willreturn memory(argmem: write) }
attributes #9 = { 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 #10 = { nounwind }
attributes #11 = { nounwind willreturn memory(read) }
attributes #12 = { nounwind allocsize(0) }
attributes #13 = { noreturn 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 = !{!10, !10, i64 0}
!10 = !{!"short", !7, i64 0}
!11 = !{!12, !13, i64 0}
!12 = !{!"", !13, i64 0, !13, i64 8, !6, i64 16}
!13 = !{!"long", !7, i64 0}
!14 = !{!15, !6, i64 88}
!15 = !{!"otfcc_GlyphOrderPackage", !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}
!16 = !{!17, !6, i64 264}
!17 = !{!"_caryll_font", !18, 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, !6, i64 128, !6, i64 136, !6, i64 144, !6, i64 152, !6, i64 160, !6, i64 168, !6, i64 176, !6, i64 184, !6, i64 192, !6, i64 200, !6, i64 208, !6, i64 216, !6, i64 224, !6, i64 232, !6, i64 240, !6, i64 248, !6, i64 256, !6, i64 264}
!18 = !{!"int", !7, i64 0}
!19 = !{!12, !6, i64 16}
!20 = !{!21, !6, i64 32}
!21 = !{!"", !22, i64 0, !22, i64 1, !22, i64 2, !22, i64 3, !22, i64 4, !22, i64 5, !22, i64 6, !22, i64 7, !22, i64 8, !22, i64 9, !22, i64 10, !22, i64 11, !22, i64 12, !22, i64 13, !22, i64 14, !22, i64 15, !22, i64 16, !22, i64 17, !22, i64 18, !22, i64 19, !22, i64 20, !22, i64 21, !22, i64 22, !6, i64 24, !6, i64 32}
!22 = !{!"_Bool", !7, i64 0}
!23 = !{!24, !6, i64 48}
!24 = !{!"otfcc_ILogger", !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}
!25 = !{!26, !6, i64 8}
!26 = !{!"", !27, i64 0, !28, i64 16, !28, i64 40}
!27 = !{!"otfcc_Handle", !18, i64 0, !10, i64 4, !6, i64 8}
!28 = !{!"", !22, i64 0, !29, i64 8, !29, i64 16}
!29 = !{!"double", !7, i64 0}
!30 = !{!26, !10, i64 4}
!31 = !{!18, !18, i64 0}
!32 = !{!7, !7, i64 0}
!33 = distinct !{!33, !34}
!34 = !{!"llvm.loop.mustprogress"}
!35 = !{!36, !6, i64 64}
!36 = !{!"", !18, i64 0, !6, i64 8, !28, i64 16, !28, i64 40, !37, i64 64}
!37 = !{!"UT_hash_handle", !6, i64 0, !6, i64 8, !6, i64 16, !6, i64 24, !6, i64 32, !6, i64 40, !18, i64 48, !18, i64 52}
!38 = !{!39, !18, i64 8}
!39 = !{!"UT_hash_table", !6, i64 0, !18, i64 8, !18, i64 12, !18, i64 16, !6, i64 24, !13, i64 32, !18, i64 40, !18, i64 44, !18, i64 48, !18, i64 52, !18, i64 56}
!40 = !{!39, !6, i64 0}
!41 = !{!42, !6, i64 0}
!42 = !{!"UT_hash_bucket", !6, i64 0, !18, i64 8, !18, i64 12}
!43 = !{!39, !13, i64 32}
!44 = !{!36, !18, i64 116}
!45 = !{!36, !18, i64 112}
!46 = !{!36, !6, i64 104}
!47 = !{!36, !6, i64 96}
!48 = distinct !{!48, !34}
!49 = !{!36, !18, i64 0}
!50 = !{!36, !6, i64 8}
!51 = !{i64 0, i64 1, !52, i64 8, i64 8, !53, i64 16, i64 8, !53}
!52 = !{!22, !22, i64 0}
!53 = !{!29, !29, i64 0}
!54 = distinct !{!54, !34}
!55 = !{!36, !6, i64 80}
!56 = !{!36, !6, i64 72}
!57 = !{!39, !6, i64 24}
!58 = !{!39, !18, i64 12}
!59 = !{!39, !18, i64 56}
!60 = !{!37, !6, i64 16}
!61 = !{!39, !18, i64 16}
!62 = !{!42, !18, i64 8}
!63 = !{!36, !6, i64 88}
!64 = !{!37, !6, i64 24}
!65 = !{!42, !18, i64 12}
!66 = !{!39, !18, i64 52}
!67 = !{!39, !18, i64 40}
!68 = !{!39, !18, i64 44}
!69 = !{!37, !6, i64 32}
!70 = !{!37, !18, i64 52}
!71 = distinct !{!71, !34}
!72 = distinct !{!72, !34}
!73 = !{!39, !18, i64 48}
!74 = distinct !{!74, !34}
!75 = distinct !{!75, !34}
!76 = !{!37, !6, i64 8}
!77 = distinct !{!77, !34}
!78 = distinct !{!78, !34}
!79 = distinct !{!79, !34}
!80 = !{!81, !6, i64 96}
!81 = !{!"__caryll_vectorinterface_subtable_gpos_cursive", !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, !6, i64 128, !6, i64 136, !6, i64 144}
!82 = !{!81, !6, i64 104}
!83 = !{!84, !6, i64 80}
!84 = !{!"otfcc_HandlePackage", !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}
!85 = distinct !{!85, !34}


; 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_GlyphOrderPackage = type { ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr }
%struct.__caryll_vectorinterface_subtable_gpos_cursive = type { ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr }
%struct.otfcc_HandlePackage = type { ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr }
%struct.otl_GposCursiveEntry = type { %struct.otfcc_Handle, %struct.otl_Anchor, %struct.otl_Anchor }
%struct.otfcc_Handle = type { i32, i16, ptr }
%struct.otl_Anchor = type { i8, double, double }
%struct.UT_hash_bucket = type { ptr, i32, i32 }

@otfcc_pkgGlyphOrder = external local_unnamed_addr constant %struct.otfcc_GlyphOrderPackage, align 8
@.str = external hidden unnamed_addr constant [42 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [68 x i8], align 1
@iSubtable_gpos_cursive = external local_unnamed_addr constant %struct.__caryll_vectorinterface_subtable_gpos_cursive, align 8
@otfcc_iHandle = external local_unnamed_addr constant %struct.otfcc_HandlePackage, align 8

; Function Attrs: nounwind uwtable
define dso_local zeroext i1 @consolidate_gpos_cursive(ptr nocapture noundef readonly %0, ptr nocapture noundef readnone %1, ptr noundef %2, ptr nocapture noundef readonly %3) local_unnamed_addr #0 {
  %5 = alloca i32, align 4
  %6 = alloca %struct.otl_GposCursiveEntry, align 8
  %7 = load i64, ptr %2, align 8, !tbaa !5
  %.not805 = icmp eq i64 %7, 0
  br i1 %.not805, label %.thread722, label %.lr.ph773

.lr.ph773:                                        ; preds = %4
  %8 = load ptr, ptr getelementptr inbounds (i8, ptr @otfcc_pkgGlyphOrder, i64 88), align 8, !tbaa !11
  %9 = getelementptr inbounds i8, ptr %0, i64 264
  %10 = getelementptr inbounds i8, ptr %2, i64 16
  %11 = getelementptr inbounds i8, ptr %3, i64 32
  br label %13

._crit_edge774:                                   ; preds = %308
  %.not = icmp eq ptr %.3, null
  br i1 %.not, label %.thread722, label %313

.thread722:                                       ; preds = %4, %._crit_edge774
  %12 = load ptr, ptr getelementptr inbounds (i8, ptr @iSubtable_gpos_cursive, i64 96), align 8, !tbaa !13
  tail call void %12(ptr noundef nonnull %2) #11
  br label %._crit_edge804

13:                                               ; preds = %.lr.ph773, %308
  %14 = phi i64 [ 0, %.lr.ph773 ], [ %310, %308 ]
  %.0770 = phi ptr [ null, %.lr.ph773 ], [ %.3, %308 ]
  %.0564769 = phi i16 [ 0, %.lr.ph773 ], [ %309, %308 ]
  %15 = load ptr, ptr %9, align 8, !tbaa !15
  %16 = load ptr, ptr %10, align 8, !tbaa !18
  %17 = getelementptr inbounds %struct.otl_GposCursiveEntry, ptr %16, i64 %14
  %18 = tail call zeroext i1 %8(ptr noundef %15, ptr noundef %17) #11
  br i1 %18, label %28, label %19

19:                                               ; preds = %13
  %20 = load ptr, ptr %11, align 8, !tbaa !19
  %21 = getelementptr inbounds i8, ptr %20, i64 48
  %22 = load ptr, ptr %21, align 8, !tbaa !22
  %23 = tail call ptr @sdsempty() #11
  %24 = load ptr, ptr %10, align 8, !tbaa !18
  %25 = getelementptr inbounds %struct.otl_GposCursiveEntry, ptr %24, i64 %14, i32 0, i32 2
  %26 = load ptr, ptr %25, align 8, !tbaa !24
  %27 = tail call ptr (ptr, ptr, ...) @sdscatprintf(ptr noundef %23, ptr noundef nonnull @.str, ptr noundef %26) #11
  tail call void %22(ptr noundef %20, i8 noundef zeroext 1, i32 noundef 1, ptr noundef %27) #11
  br label %308

28:                                               ; preds = %13
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %5) #11
  %29 = load ptr, ptr %10, align 8, !tbaa !18
  %30 = getelementptr inbounds %struct.otl_GposCursiveEntry, ptr %29, i64 %14, i32 0, i32 1
  %31 = load i16, ptr %30, align 4, !tbaa !30
  %32 = zext i16 %31 to i32
  store i32 %32, ptr %5, align 4, !tbaa !31
  %33 = and i16 %31, -256
  %34 = zext i16 %33 to i32
  %35 = and i16 %31, 255
  %36 = zext nneg i16 %35 to i32
  %37 = add nuw nsw i32 %34, 17973517
  %38 = add nuw nsw i32 %37, %36
  %39 = xor i32 %38, 522093
  %40 = sub nuw nsw i32 -1622558010, %39
  %41 = shl i32 %39, 8
  %42 = xor i32 %40, %41
  %43 = add nuw nsw i32 %39, %42
  %44 = sub nuw nsw i32 -17973517, %43
  %45 = lshr i32 %42, 13
  %46 = xor i32 %44, %45
  %47 = add nuw nsw i32 %42, %46
  %48 = sub nsw i32 %39, %47
  %49 = lshr i32 %46, 12
  %50 = xor i32 %48, %49
  %51 = add nuw nsw i32 %46, %50
  %52 = sub nuw i32 %42, %51
  %53 = shl i32 %50, 16
  %54 = xor i32 %52, %53
  %55 = add i32 %50, %54
  %56 = sub i32 %46, %55
  %57 = lshr i32 %54, 5
  %58 = xor i32 %56, %57
  %59 = add i32 %54, %58
  %60 = sub i32 %50, %59
  %61 = lshr i32 %58, 3
  %62 = xor i32 %60, %61
  %63 = add i32 %58, %62
  %64 = sub i32 %54, %63
  %65 = shl i32 %62, 10
  %66 = xor i32 %64, %65
  %67 = add i32 %62, %66
  %68 = sub i32 %58, %67
  %69 = lshr i32 %66, 15
  %70 = xor i32 %68, %69
  %.not695 = icmp eq ptr %.0770, null
  br i1 %.not695, label %.loopexit756, label %71

71:                                               ; preds = %28
  %72 = getelementptr inbounds i8, ptr %.0770, i64 64
  %73 = load ptr, ptr %72, align 8, !tbaa !32
  %74 = getelementptr inbounds i8, ptr %73, i64 8
  %75 = load i32, ptr %74, align 8, !tbaa !35
  %76 = add i32 %75, -1
  %77 = and i32 %76, %70
  %78 = load ptr, ptr %73, align 8, !tbaa !37
  %79 = zext i32 %77 to i64
  %80 = getelementptr inbounds %struct.UT_hash_bucket, ptr %78, i64 %79
  %81 = load ptr, ptr %80, align 8, !tbaa !38
  %.not696 = icmp eq ptr %81, null
  br i1 %.not696, label %.loopexit756, label %.lr.ph

.lr.ph:                                           ; preds = %71
  %82 = getelementptr inbounds i8, ptr %73, i64 32
  %83 = load i64, ptr %82, align 8, !tbaa !40
  %84 = sub i64 0, %83
  %85 = getelementptr inbounds i8, ptr %81, i64 %84
  %86 = getelementptr inbounds i8, ptr %73, i64 32
  br label %87

87:                                               ; preds = %102, %.lr.ph
  %.1566761 = phi ptr [ %85, %.lr.ph ], [ %105, %102 ]
  %88 = getelementptr inbounds i8, ptr %.1566761, i64 116
  %89 = load i32, ptr %88, align 4, !tbaa !41
  %90 = icmp eq i32 %89, %70
  br i1 %90, label %91, label %99

91:                                               ; preds = %87
  %92 = getelementptr inbounds i8, ptr %.1566761, i64 112
  %93 = load i32, ptr %92, align 8, !tbaa !42
  %94 = icmp eq i32 %93, 4
  br i1 %94, label %95, label %99

95:                                               ; preds = %91
  %96 = getelementptr inbounds i8, ptr %.1566761, i64 104
  %97 = load ptr, ptr %96, align 8, !tbaa !43
  %bcmp = call i32 @bcmp(ptr noundef nonnull dereferenceable(4) %97, ptr noundef nonnull dereferenceable(4) %5, i64 4)
  %98 = icmp eq i32 %bcmp, 0
  br i1 %98, label %106, label %99

99:                                               ; preds = %95, %91, %87
  %100 = getelementptr inbounds i8, ptr %.1566761, i64 96
  %101 = load ptr, ptr %100, align 8, !tbaa !44
  %.not698 = icmp eq ptr %101, null
  br i1 %.not698, label %.loopexit756, label %102

102:                                              ; preds = %99
  %103 = load i64, ptr %86, align 8, !tbaa !40
  %104 = sub i64 0, %103
  %105 = getelementptr inbounds i8, ptr %101, i64 %104
  br label %87, !llvm.loop !45

106:                                              ; preds = %95
  %107 = load ptr, ptr %11, align 8, !tbaa !19
  %108 = getelementptr inbounds i8, ptr %107, i64 48
  %109 = load ptr, ptr %108, align 8, !tbaa !22
  %110 = tail call ptr @sdsempty() #11
  %111 = load ptr, ptr %10, align 8, !tbaa !18
  %112 = getelementptr inbounds %struct.otl_GposCursiveEntry, ptr %111, i64 %14, i32 0, i32 2
  %113 = load ptr, ptr %112, align 8, !tbaa !24
  %114 = tail call ptr (ptr, ptr, ...) @sdscatprintf(ptr noundef %110, ptr noundef nonnull @.str.1, ptr noundef %113) #11
  tail call void %109(ptr noundef %107, i8 noundef zeroext 1, i32 noundef 1, ptr noundef %114) #11
  br label %307

.loopexit756:                                     ; preds = %99, %71, %28
  %115 = tail call ptr @__caryll_allocate_clean(i64 noundef 120, i64 noundef 30)
  %116 = load ptr, ptr %10, align 8, !tbaa !18
  %117 = getelementptr inbounds %struct.otl_GposCursiveEntry, ptr %116, i64 %14, i32 0, i32 1
  %118 = load i16, ptr %117, align 4, !tbaa !30
  %119 = zext i16 %118 to i32
  store i32 %119, ptr %115, align 8, !tbaa !47
  %120 = getelementptr inbounds %struct.otl_GposCursiveEntry, ptr %116, i64 %14, i32 0, i32 2
  %121 = load ptr, ptr %120, align 8, !tbaa !24
  %122 = tail call ptr @sdsdup(ptr noundef %121) #11
  %123 = getelementptr inbounds i8, ptr %115, i64 8
  store ptr %122, ptr %123, align 8, !tbaa !48
  %124 = getelementptr inbounds i8, ptr %115, i64 16
  %125 = load ptr, ptr %10, align 8, !tbaa !18
  %126 = getelementptr inbounds %struct.otl_GposCursiveEntry, ptr %125, i64 %14, i32 1
  tail call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 8 dereferenceable(24) %124, ptr noundef nonnull align 8 dereferenceable(24) %126, i64 24, i1 false), !tbaa.struct !49
  %127 = getelementptr inbounds i8, ptr %115, i64 40
  %128 = load ptr, ptr %10, align 8, !tbaa !18
  %129 = getelementptr inbounds %struct.otl_GposCursiveEntry, ptr %128, i64 %14, i32 2
  tail call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 8 dereferenceable(24) %127, ptr noundef nonnull align 8 dereferenceable(24) %129, i64 24, i1 false), !tbaa.struct !49
  %130 = getelementptr inbounds i8, ptr %115, i64 3
  %131 = load i8, ptr %130, align 1, !tbaa !52
  %132 = zext i8 %131 to i32
  %133 = shl nuw i32 %132, 24
  %134 = getelementptr inbounds i8, ptr %115, i64 2
  %135 = load i8, ptr %134, align 1, !tbaa !52
  %136 = zext i8 %135 to i32
  %137 = shl nuw nsw i32 %136, 16
  %138 = getelementptr inbounds i8, ptr %115, i64 1
  %139 = load i8, ptr %138, align 1, !tbaa !52
  %140 = zext i8 %139 to i32
  %141 = shl nuw nsw i32 %140, 8
  %142 = load i8, ptr %115, align 1, !tbaa !52
  %143 = zext i8 %142 to i32
  %144 = add i32 %133, 17973517
  %145 = add i32 %144, %137
  %146 = add i32 %145, %141
  %147 = add i32 %146, %143
  %148 = xor i32 %147, 522093
  %149 = sub i32 -1622558010, %148
  %150 = shl i32 %148, 8
  %151 = xor i32 %149, %150
  %152 = add i32 %148, %151
  %153 = sub i32 -17973517, %152
  %154 = lshr i32 %151, 13
  %155 = xor i32 %153, %154
  %156 = add i32 %151, %155
  %157 = sub i32 %148, %156
  %158 = lshr i32 %155, 12
  %159 = xor i32 %157, %158
  %160 = add i32 %155, %159
  %161 = sub i32 %151, %160
  %162 = shl i32 %159, 16
  %163 = xor i32 %161, %162
  %164 = add i32 %159, %163
  %165 = sub i32 %155, %164
  %166 = lshr i32 %163, 5
  %167 = xor i32 %165, %166
  %168 = add i32 %163, %167
  %169 = sub i32 %159, %168
  %170 = lshr i32 %167, 3
  %171 = xor i32 %169, %170
  %172 = add i32 %167, %171
  %173 = sub i32 %163, %172
  %174 = shl i32 %171, 10
  %175 = xor i32 %173, %174
  %176 = add i32 %171, %175
  %177 = sub i32 %167, %176
  %178 = lshr i32 %175, 15
  %179 = xor i32 %177, %178
  %180 = getelementptr inbounds i8, ptr %115, i64 64
  %181 = getelementptr inbounds i8, ptr %115, i64 116
  store i32 %179, ptr %181, align 4, !tbaa !41
  %182 = getelementptr inbounds i8, ptr %115, i64 104
  store ptr %115, ptr %182, align 8, !tbaa !43
  %183 = getelementptr inbounds i8, ptr %115, i64 112
  store i32 4, ptr %183, align 8, !tbaa !42
  br i1 %.not695, label %184, label %198

184:                                              ; preds = %.loopexit756
  %185 = getelementptr inbounds i8, ptr %115, i64 72
  %186 = tail call noalias dereferenceable_or_null(64) ptr @malloc(i64 noundef 64) #12
  tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %185, i8 0, i64 16, i1 false)
  store ptr %186, ptr %180, align 8, !tbaa !32
  %.not700 = icmp eq ptr %186, null
  br i1 %.not700, label %187, label %188

187:                                              ; preds = %184
  tail call void @exit(i32 noundef -1) #13
  unreachable

188:                                              ; preds = %184
  tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(64) %186, i8 0, i64 64, i1 false)
  %189 = load ptr, ptr %180, align 8, !tbaa !32
  %190 = getelementptr inbounds i8, ptr %189, i64 24
  store ptr %180, ptr %190, align 8, !tbaa !53
  %191 = getelementptr inbounds i8, ptr %189, i64 8
  store i32 32, ptr %191, align 8, !tbaa !35
  %192 = getelementptr inbounds i8, ptr %189, i64 12
  store i32 5, ptr %192, align 4, !tbaa !54
  %193 = getelementptr inbounds i8, ptr %189, i64 32
  store i64 64, ptr %193, align 8, !tbaa !40
  %194 = tail call noalias dereferenceable_or_null(512) ptr @malloc(i64 noundef 512) #12
  store ptr %194, ptr %189, align 8, !tbaa !37
  %195 = getelementptr inbounds i8, ptr %189, i64 56
  store i32 -1609490463, ptr %195, align 8, !tbaa !55
  %.not701 = icmp eq ptr %194, null
  br i1 %.not701, label %196, label %197

196:                                              ; preds = %188
  tail call void @exit(i32 noundef -1) #13
  unreachable

197:                                              ; preds = %188
  tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(512) %194, i8 0, i64 512, i1 false)
  %.pre = load ptr, ptr %180, align 8, !tbaa !32
  br label %210

198:                                              ; preds = %.loopexit756
  %199 = getelementptr inbounds i8, ptr %.0770, i64 64
  %200 = load ptr, ptr %199, align 8, !tbaa !32
  store ptr %200, ptr %180, align 8, !tbaa !32
  %201 = getelementptr inbounds i8, ptr %115, i64 80
  store ptr null, ptr %201, align 8, !tbaa !56
  %202 = getelementptr inbounds i8, ptr %200, i64 24
  %203 = load ptr, ptr %202, align 8, !tbaa !53
  %204 = getelementptr inbounds i8, ptr %200, i64 32
  %205 = load i64, ptr %204, align 8, !tbaa !40
  %206 = sub i64 0, %205
  %207 = getelementptr inbounds i8, ptr %203, i64 %206
  %208 = getelementptr inbounds i8, ptr %115, i64 72
  store ptr %207, ptr %208, align 8, !tbaa !57
  %209 = getelementptr inbounds i8, ptr %203, i64 16
  store ptr %115, ptr %209, align 8, !tbaa !58
  store ptr %180, ptr %202, align 8, !tbaa !53
  br label %210

210:                                              ; preds = %197, %198
  %211 = phi ptr [ %200, %198 ], [ %.pre, %197 ]
  %.1 = phi ptr [ %.0770, %198 ], [ %115, %197 ]
  %212 = getelementptr inbounds i8, ptr %211, i64 16
  %213 = load i32, ptr %212, align 8, !tbaa !59
  %214 = add i32 %213, 1
  store i32 %214, ptr %212, align 8, !tbaa !59
  %215 = getelementptr inbounds i8, ptr %211, i64 8
  %216 = load i32, ptr %215, align 8, !tbaa !35
  %217 = add i32 %216, -1
  %218 = and i32 %217, %179
  %219 = load ptr, ptr %211, align 8, !tbaa !37
  %220 = zext i32 %218 to i64
  %221 = getelementptr inbounds %struct.UT_hash_bucket, ptr %219, i64 %220
  %222 = getelementptr inbounds i8, ptr %221, i64 8
  %223 = load i32, ptr %222, align 8, !tbaa !60
  %224 = add i32 %223, 1
  store i32 %224, ptr %222, align 8, !tbaa !60
  %225 = load ptr, ptr %221, align 8, !tbaa !38
  %226 = getelementptr inbounds i8, ptr %115, i64 96
  store ptr %225, ptr %226, align 8, !tbaa !44
  %227 = getelementptr inbounds i8, ptr %115, i64 88
  store ptr null, ptr %227, align 8, !tbaa !61
  %.not702 = icmp eq ptr %225, null
  br i1 %.not702, label %230, label %228

228:                                              ; preds = %210
  %229 = getelementptr inbounds i8, ptr %225, i64 24
  store ptr %180, ptr %229, align 8, !tbaa !62
  br label %230

230:                                              ; preds = %228, %210
  store ptr %180, ptr %221, align 8, !tbaa !38
  %231 = getelementptr inbounds i8, ptr %221, i64 12
  %232 = load i32, ptr %231, align 4, !tbaa !63
  %233 = mul i32 %232, 10
  %234 = add i32 %233, 10
  %.not703 = icmp ult i32 %224, %234
  br i1 %.not703, label %307, label %235

235:                                              ; preds = %230
  %236 = getelementptr inbounds i8, ptr %211, i64 52
  %237 = load i32, ptr %236, align 4, !tbaa !64
  %.not704 = icmp eq i32 %237, 0
  br i1 %.not704, label %238, label %307

238:                                              ; preds = %235
  %239 = zext i32 %216 to i64
  %240 = shl nuw nsw i64 %239, 5
  %calloc = tail call ptr @calloc(i64 1, i64 %240)
  %.not705 = icmp eq ptr %calloc, null
  br i1 %.not705, label %241, label %242

241:                                              ; preds = %238
  tail call void @exit(i32 noundef -1) #13
  unreachable

242:                                              ; preds = %238
  %243 = load ptr, ptr %180, align 8, !tbaa !32
  %244 = getelementptr inbounds i8, ptr %243, i64 16
  %245 = load i32, ptr %244, align 8, !tbaa !59
  %246 = getelementptr inbounds i8, ptr %243, i64 12
  %247 = load i32, ptr %246, align 4, !tbaa !54
  %248 = add i32 %247, 1
  %249 = lshr i32 %245, %248
  %250 = getelementptr inbounds i8, ptr %243, i64 8
  %251 = load i32, ptr %250, align 8, !tbaa !35
  %252 = shl i32 %251, 1
  %253 = add i32 %252, -1
  %254 = and i32 %253, %245
  %.not706 = icmp ne i32 %254, 0
  %255 = zext i1 %.not706 to i32
  %256 = add i32 %249, %255
  %257 = getelementptr inbounds i8, ptr %243, i64 40
  store i32 %256, ptr %257, align 8, !tbaa !65
  %258 = getelementptr inbounds i8, ptr %243, i64 44
  store i32 0, ptr %258, align 4, !tbaa !66
  %.not806 = icmp eq i32 %251, 0
  %.pre811 = load ptr, ptr %243, align 8, !tbaa !37
  br i1 %.not806, label %._crit_edge768, label %.lr.ph767

.lr.ph767:                                        ; preds = %242
  %wide.trip.count = zext i32 %251 to i64
  br label %259

259:                                              ; preds = %.lr.ph767, %._crit_edge
  %260 = phi i32 [ 0, %.lr.ph767 ], [ %286, %._crit_edge ]
  %indvars.iv = phi i64 [ 0, %.lr.ph767 ], [ %indvars.iv.next, %._crit_edge ]
  %261 = getelementptr inbounds %struct.UT_hash_bucket, ptr %.pre811, i64 %indvars.iv
  %262 = load ptr, ptr %261, align 8, !tbaa !38
  %.not707762 = icmp eq ptr %262, null
  br i1 %.not707762, label %._crit_edge, label %.lr.ph764

.lr.ph764:                                        ; preds = %259, %285
  %263 = phi i32 [ %280, %285 ], [ %260, %259 ]
  %.0622763 = phi ptr [ %265, %285 ], [ %262, %259 ]
  %264 = getelementptr inbounds i8, ptr %.0622763, i64 32
  %265 = load ptr, ptr %264, align 8, !tbaa !67
  %266 = getelementptr inbounds i8, ptr %.0622763, i64 52
  %267 = load i32, ptr %266, align 4, !tbaa !68
  %268 = and i32 %267, %253
  %269 = zext i32 %268 to i64
  %270 = getelementptr inbounds %struct.UT_hash_bucket, ptr %calloc, i64 %269
  %271 = getelementptr inbounds i8, ptr %270, i64 8
  %272 = load i32, ptr %271, align 8, !tbaa !60
  %273 = add i32 %272, 1
  store i32 %273, ptr %271, align 8, !tbaa !60
  %274 = icmp ugt i32 %273, %256
  br i1 %274, label %275, label %279

275:                                              ; preds = %.lr.ph764
  %276 = add i32 %263, 1
  store i32 %276, ptr %258, align 4, !tbaa !66
  %277 = udiv i32 %273, %256
  %278 = getelementptr inbounds i8, ptr %270, i64 12
  store i32 %277, ptr %278, align 4, !tbaa !63
  br label %279

279:                                              ; preds = %275, %.lr.ph764
  %280 = phi i32 [ %276, %275 ], [ %263, %.lr.ph764 ]
  %281 = getelementptr inbounds i8, ptr %.0622763, i64 24
  store ptr null, ptr %281, align 8, !tbaa !62
  %282 = load ptr, ptr %270, align 8, !tbaa !38
  store ptr %282, ptr %264, align 8, !tbaa !67
  %.not708 = icmp eq ptr %282, null
  br i1 %.not708, label %285, label %283

283:                                              ; preds = %279
  %284 = getelementptr inbounds i8, ptr %282, i64 24
  store ptr %.0622763, ptr %284, align 8, !tbaa !62
  br label %285

285:                                              ; preds = %283, %279
  store ptr %.0622763, ptr %270, align 8, !tbaa !38
  %.not707 = icmp eq ptr %265, null
  br i1 %.not707, label %._crit_edge, label %.lr.ph764, !llvm.loop !69

._crit_edge:                                      ; preds = %285, %259
  %286 = phi i32 [ %260, %259 ], [ %280, %285 ]
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %exitcond.not = icmp eq i64 %indvars.iv.next, %wide.trip.count
  br i1 %exitcond.not, label %._crit_edge768, label %259, !llvm.loop !70

._crit_edge768:                                   ; preds = %._crit_edge, %242
  tail call void @free(ptr noundef %.pre811) #11
  %287 = load ptr, ptr %180, align 8, !tbaa !32
  %288 = getelementptr inbounds i8, ptr %287, i64 8
  %289 = load i32, ptr %288, align 8, !tbaa !35
  %290 = shl i32 %289, 1
  store i32 %290, ptr %288, align 8, !tbaa !35
  %291 = getelementptr inbounds i8, ptr %287, i64 12
  %292 = load i32, ptr %291, align 4, !tbaa !54
  %293 = add i32 %292, 1
  store i32 %293, ptr %291, align 4, !tbaa !54
  store ptr %calloc, ptr %287, align 8, !tbaa !37
  %294 = getelementptr inbounds i8, ptr %287, i64 44
  %295 = load i32, ptr %294, align 4, !tbaa !66
  %296 = getelementptr inbounds i8, ptr %287, i64 16
  %297 = load i32, ptr %296, align 8, !tbaa !59
  %298 = lshr i32 %297, 1
  %299 = icmp ugt i32 %295, %298
  %300 = getelementptr inbounds i8, ptr %287, i64 48
  br i1 %299, label %301, label %.thread711

.thread711:                                       ; preds = %._crit_edge768
  store i32 0, ptr %300, align 8, !tbaa !71
  br label %307

301:                                              ; preds = %._crit_edge768
  %302 = load i32, ptr %300, align 8, !tbaa !71
  %303 = add i32 %302, 1
  store i32 %303, ptr %300, align 8, !tbaa !71
  %304 = icmp ugt i32 %303, 1
  br i1 %304, label %305, label %307

305:                                              ; preds = %301
  %306 = getelementptr inbounds i8, ptr %287, i64 52
  store i32 1, ptr %306, align 4, !tbaa !64
  br label %307

307:                                              ; preds = %.thread711, %230, %235, %301, %305, %106
  %.2 = phi ptr [ %.0770, %106 ], [ %.1, %305 ], [ %.1, %301 ], [ %.1, %235 ], [ %.1, %230 ], [ %.1, %.thread711 ]
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %5) #11
  br label %308

308:                                              ; preds = %307, %19
  %.3 = phi ptr [ %.2, %307 ], [ %.0770, %19 ]
  %309 = add i16 %.0564769, 1
  %310 = zext i16 %309 to i64
  %311 = load i64, ptr %2, align 8, !tbaa !5
  %312 = icmp ugt i64 %311, %310
  br i1 %312, label %13, label %._crit_edge774, !llvm.loop !72

313:                                              ; preds = %._crit_edge774
  %314 = getelementptr inbounds i8, ptr %.3, i64 64
  %315 = getelementptr inbounds i8, ptr %.3, i64 64
  br label %.lr.ph790

.preheader:                                       ; preds = %403
  %316 = shl i32 %.0593795849, 1
  %.not682785 = icmp eq ptr %.2575.ph, null
  br i1 %.not682785, label %.thread831, label %.lr.ph790

.lr.ph790:                                        ; preds = %313, %.preheader
  %.0593795849 = phi i32 [ 1, %313 ], [ %316, %.preheader ]
  %.0573796848 = phi ptr [ %314, %313 ], [ %.2575.ph, %.preheader ]
  %.not807 = icmp eq i32 %.0593795849, 0
  br label %317

.loopexit:                                        ; preds = %327
  %.not682 = icmp eq ptr %.2580, null
  br i1 %.not682, label %._crit_edge791, label %317, !llvm.loop !73

317:                                              ; preds = %.lr.ph790, %.loopexit
  %.0571789 = phi ptr [ null, %.lr.ph790 ], [ %.1572, %.loopexit ]
  %.1574788 = phi ptr [ null, %.lr.ph790 ], [ %.2575.ph, %.loopexit ]
  %.0582787 = phi ptr [ %.0573796848, %.lr.ph790 ], [ %.2580, %.loopexit ]
  %.0594786 = phi i32 [ 0, %.lr.ph790 ], [ %318, %.loopexit ]
  %318 = add i32 %.0594786, 1
  br i1 %.not807, label %.thread712.preheader, label %.lr.ph779

.lr.ph779:                                        ; preds = %317, %322
  %.0578777 = phi ptr [ %326, %322 ], [ %.0582787, %317 ]
  %.0589776 = phi i32 [ %319, %322 ], [ 0, %317 ]
  %319 = add nuw i32 %.0589776, 1
  %320 = getelementptr inbounds i8, ptr %.0578777, i64 16
  %321 = load ptr, ptr %320, align 8, !tbaa !58
  %.not684 = icmp eq ptr %321, null
  br i1 %.not684, label %.thread712.preheader, label %322

322:                                              ; preds = %.lr.ph779
  %323 = load ptr, ptr %315, align 8, !tbaa !32
  %324 = getelementptr inbounds i8, ptr %323, i64 32
  %325 = load i64, ptr %324, align 8, !tbaa !40
  %326 = getelementptr inbounds i8, ptr %321, i64 %325
  %exitcond810.not = icmp eq i32 %319, %.0593795849
  br i1 %exitcond810.not, label %.thread712.preheader, label %.lr.ph779, !llvm.loop !74

.thread712.preheader:                             ; preds = %322, %.lr.ph779, %317
  %.2591.ph = phi i32 [ 0, %317 ], [ %319, %.lr.ph779 ], [ %.0593795849, %322 ]
  %.2580.ph = phi ptr [ %.0582787, %317 ], [ null, %.lr.ph779 ], [ %326, %322 ]
  br label %.thread712.outer

.thread712.outer:                                 ; preds = %.thread712.outer.backedge, %.thread712.preheader
  %.2591.ph850 = phi i32 [ %.2591.ph, %.thread712.preheader ], [ %.3592, %.thread712.outer.backedge ]
  %.0587.ph = phi i32 [ %.0593795849, %.thread712.preheader ], [ %.1588, %.thread712.outer.backedge ]
  %.1583.ph = phi ptr [ %.0582787, %.thread712.preheader ], [ %.4586, %.thread712.outer.backedge ]
  %.2580.ph851 = phi ptr [ %.2580.ph, %.thread712.preheader ], [ %.3581, %.thread712.outer.backedge ]
  %.2575.ph = phi ptr [ %.1574788, %.thread712.preheader ], [ %.2575.ph.be, %.thread712.outer.backedge ]
  %.1572.ph = phi ptr [ %.0571789, %.thread712.preheader ], [ %.0577, %.thread712.outer.backedge ]
  br label %.thread712

.thread712:                                       ; preds = %.thread712.outer, %.thread713.thread
  %.2591 = phi i32 [ %.3592, %.thread713.thread ], [ %.2591.ph850, %.thread712.outer ]
  %.0587 = phi i32 [ %.1588, %.thread713.thread ], [ %.0587.ph, %.thread712.outer ]
  %.1583 = phi ptr [ %.4586, %.thread713.thread ], [ %.1583.ph, %.thread712.outer ]
  %.2580 = phi ptr [ %.3581, %.thread713.thread ], [ %.2580.ph851, %.thread712.outer ]
  %.1572 = phi ptr [ %.0577, %.thread713.thread ], [ %.1572.ph, %.thread712.outer ]
  %cond = icmp eq i32 %.2591, 0
  br i1 %cond, label %327, label %341

327:                                              ; preds = %.thread712
  %328 = icmp ne i32 %.0587, 0
  %329 = icmp ne ptr %.2580, null
  %330 = select i1 %328, i1 %329, i1 false
  br i1 %330, label %.critedge, label %.loopexit

.critedge:                                        ; preds = %327
  %331 = getelementptr inbounds i8, ptr %.2580, i64 16
  %332 = load ptr, ptr %331, align 8, !tbaa !58
  %.not691 = icmp eq ptr %332, null
  br i1 %.not691, label %338, label %333

333:                                              ; preds = %.critedge
  %334 = load ptr, ptr %315, align 8, !tbaa !32
  %335 = getelementptr inbounds i8, ptr %334, i64 32
  %336 = load i64, ptr %335, align 8, !tbaa !40
  %337 = getelementptr inbounds i8, ptr %332, i64 %336
  br label %338

338:                                              ; preds = %.critedge, %333
  %339 = phi ptr [ %337, %333 ], [ null, %.critedge ]
  %340 = add i32 %.0587, -1
  br label %386

341:                                              ; preds = %.thread712
  %342 = icmp eq i32 %.0587, 0
  %343 = icmp eq ptr %.2580, null
  %or.cond = select i1 %342, i1 true, i1 %343
  br i1 %or.cond, label %344, label %355

344:                                              ; preds = %341
  %.not689 = icmp eq ptr %.1583, null
  br i1 %.not689, label %353, label %345

345:                                              ; preds = %344
  %346 = getelementptr inbounds i8, ptr %.1583, i64 16
  %347 = load ptr, ptr %346, align 8, !tbaa !58
  %.not690 = icmp eq ptr %347, null
  br i1 %.not690, label %353, label %348

348:                                              ; preds = %345
  %349 = load ptr, ptr %315, align 8, !tbaa !32
  %350 = getelementptr inbounds i8, ptr %349, i64 32
  %351 = load i64, ptr %350, align 8, !tbaa !40
  %352 = getelementptr inbounds i8, ptr %347, i64 %351
  br label %353

353:                                              ; preds = %348, %345, %344
  %.2584 = phi ptr [ null, %344 ], [ %352, %348 ], [ null, %345 ]
  %354 = add i32 %.2591, -1
  br label %386

355:                                              ; preds = %341
  %356 = load ptr, ptr %315, align 8, !tbaa !32
  %357 = getelementptr inbounds i8, ptr %356, i64 32
  %358 = load i64, ptr %357, align 8, !tbaa !40
  %359 = sub i64 0, %358
  %360 = getelementptr inbounds i8, ptr %.1583, i64 %359
  %361 = getelementptr inbounds i8, ptr %.2580, i64 %359
  %362 = tail call i32 @gpos_cursive_by_from_id(ptr noundef %360, ptr noundef %361)
  %363 = icmp slt i32 %362, 1
  br i1 %363, label %364, label %375

364:                                              ; preds = %355
  %.not687 = icmp eq ptr %.1583, null
  br i1 %.not687, label %373, label %365

365:                                              ; preds = %364
  %366 = getelementptr inbounds i8, ptr %.1583, i64 16
  %367 = load ptr, ptr %366, align 8, !tbaa !58
  %.not688 = icmp eq ptr %367, null
  br i1 %.not688, label %373, label %368

368:                                              ; preds = %365
  %369 = load ptr, ptr %315, align 8, !tbaa !32
  %370 = getelementptr inbounds i8, ptr %369, i64 32
  %371 = load i64, ptr %370, align 8, !tbaa !40
  %372 = getelementptr inbounds i8, ptr %367, i64 %371
  br label %373

373:                                              ; preds = %368, %365, %364
  %.3585 = phi ptr [ null, %364 ], [ %372, %368 ], [ null, %365 ]
  %374 = add i32 %.2591, -1
  br label %386

375:                                              ; preds = %355
  %376 = getelementptr inbounds i8, ptr %.2580, i64 16
  %377 = load ptr, ptr %376, align 8, !tbaa !58
  %.not686 = icmp eq ptr %377, null
  br i1 %.not686, label %383, label %378

378:                                              ; preds = %375
  %379 = load ptr, ptr %315, align 8, !tbaa !32
  %380 = getelementptr inbounds i8, ptr %379, i64 32
  %381 = load i64, ptr %380, align 8, !tbaa !40
  %382 = getelementptr inbounds i8, ptr %377, i64 %381
  br label %383

383:                                              ; preds = %375, %378
  %384 = phi ptr [ %382, %378 ], [ null, %375 ]
  %385 = add i32 %.0587, -1
  br label %386

386:                                              ; preds = %353, %383, %373, %338
  %.3592 = phi i32 [ 0, %338 ], [ %354, %353 ], [ %374, %373 ], [ %.2591, %383 ]
  %.1588 = phi i32 [ %340, %338 ], [ %.0587, %353 ], [ %.0587, %373 ], [ %385, %383 ]
  %.4586 = phi ptr [ %.1583, %338 ], [ %.2584, %353 ], [ %.3585, %373 ], [ %.1583, %383 ]
  %.3581 = phi ptr [ %339, %338 ], [ %.2580, %353 ], [ %.2580, %373 ], [ %384, %383 ]
  %.0577 = phi ptr [ %.2580, %338 ], [ %.1583, %353 ], [ %.1583, %373 ], [ %.2580, %383 ]
  %.not692 = icmp eq ptr %.1572, null
  %.not694 = icmp eq ptr %.0577, null
  br i1 %.not692, label %389, label %387

387:                                              ; preds = %386
  br i1 %.not694, label %.thread713.thread, label %390

.thread713.thread:                                ; preds = %387
  %388 = getelementptr inbounds i8, ptr %.1572, i64 16
  store ptr null, ptr %388, align 8, !tbaa !58
  br label %.thread712, !llvm.loop !75

389:                                              ; preds = %386
  br i1 %.not694, label %.thread712.outer.backedge, label %398

390:                                              ; preds = %387
  %391 = load ptr, ptr %315, align 8, !tbaa !32
  %392 = getelementptr inbounds i8, ptr %391, i64 32
  %393 = load i64, ptr %392, align 8, !tbaa !40
  %394 = sub i64 0, %393
  %395 = getelementptr inbounds i8, ptr %.0577, i64 %394
  %396 = getelementptr inbounds i8, ptr %.1572, i64 16
  store ptr %395, ptr %396, align 8, !tbaa !58
  %397 = getelementptr inbounds i8, ptr %.1572, i64 %394
  br label %398

398:                                              ; preds = %389, %390
  %.3576716721 = phi ptr [ %.2575.ph, %390 ], [ %.0577, %389 ]
  %399 = phi ptr [ %397, %390 ], [ null, %389 ]
  %400 = getelementptr inbounds i8, ptr %.0577, i64 8
  store ptr %399, ptr %400, align 8, !tbaa !76
  br label %.thread712.outer.backedge

.thread712.outer.backedge:                        ; preds = %398, %389
  %.2575.ph.be = phi ptr [ null, %389 ], [ %.3576716721, %398 ]
  br label %.thread712.outer, !llvm.loop !75

._crit_edge791:                                   ; preds = %.loopexit
  %.not683 = icmp eq ptr %.1572, null
  br i1 %.not683, label %403, label %401

401:                                              ; preds = %._crit_edge791
  %402 = getelementptr inbounds i8, ptr %.1572, i64 16
  store ptr null, ptr %402, align 8, !tbaa !58
  br label %403

403:                                              ; preds = %401, %._crit_edge791
  %.0571.lcssa830 = phi ptr [ %.1572, %401 ], [ null, %._crit_edge791 ]
  %404 = icmp ult i32 %318, 2
  br i1 %404, label %.thread831, label %.preheader

.thread831:                                       ; preds = %.preheader, %403
  %.1574.lcssa829836 = phi ptr [ %.2575.ph, %403 ], [ null, %.preheader ]
  %.0571.lcssa830835 = phi ptr [ %.0571.lcssa830, %403 ], [ null, %.preheader ]
  %405 = getelementptr inbounds i8, ptr %.3, i64 64
  %406 = load ptr, ptr %405, align 8, !tbaa !32
  %407 = getelementptr inbounds i8, ptr %406, i64 24
  store ptr %.0571.lcssa830835, ptr %407, align 8, !tbaa !53
  %408 = getelementptr inbounds i8, ptr %406, i64 32
  %409 = load i64, ptr %408, align 8, !tbaa !40
  %410 = load ptr, ptr getelementptr inbounds (i8, ptr @iSubtable_gpos_cursive, i64 96), align 8, !tbaa !13
  tail call void %410(ptr noundef nonnull %2) #11
  %.not675 = icmp eq ptr %.1574.lcssa829836, null
  br i1 %.not675, label %._crit_edge804, label %.lr.ph803

.lr.ph803:                                        ; preds = %.thread831
  %411 = sub i64 0, %409
  %412 = getelementptr inbounds i8, ptr %.1574.lcssa829836, i64 %411
  %413 = load ptr, ptr getelementptr inbounds (i8, ptr @iSubtable_gpos_cursive, i64 104), align 8, !tbaa !77
  %414 = load ptr, ptr getelementptr inbounds (i8, ptr @otfcc_iHandle, i64 80), align 8, !tbaa !78
  %415 = getelementptr inbounds i8, ptr %6, i64 8
  %416 = getelementptr inbounds i8, ptr %6, i64 16
  %417 = getelementptr inbounds i8, ptr %6, i64 40
  br label %418

418:                                              ; preds = %494, %.lr.ph803
  %.7801 = phi ptr [ %412, %.lr.ph803 ], [ %.9, %494 ]
  %.0570799 = phi ptr [ %412, %.lr.ph803 ], [ %.0569800, %494 ]
  %.0569800.in = getelementptr inbounds i8, ptr %.0570799, i64 80
  %.0569800 = load ptr, ptr %.0569800.in, align 8, !tbaa !56
  %419 = load i32, ptr %.0570799, align 8, !tbaa !47
  %420 = trunc i32 %419 to i16
  %421 = getelementptr inbounds i8, ptr %.0570799, i64 8
  %422 = load ptr, ptr %421, align 8, !tbaa !48
  %423 = tail call { i64, ptr } %414(i16 noundef zeroext %420, ptr noundef %422) #11
  %424 = extractvalue { i64, ptr } %423, 0
  store i64 %424, ptr %6, align 8
  %425 = extractvalue { i64, ptr } %423, 1
  store ptr %425, ptr %415, align 8
  %426 = getelementptr inbounds i8, ptr %.0570799, i64 16
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 8 dereferenceable(24) %416, ptr noundef nonnull align 8 dereferenceable(24) %426, i64 24, i1 false), !tbaa.struct !49
  %427 = getelementptr inbounds i8, ptr %.0570799, i64 40
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 8 dereferenceable(24) %417, ptr noundef nonnull align 8 dereferenceable(24) %427, i64 24, i1 false), !tbaa.struct !49
  tail call void %413(ptr noundef nonnull %2, ptr noundef nonnull byval(%struct.otl_GposCursiveEntry) align 8 %6) #11
  %428 = load ptr, ptr %421, align 8, !tbaa !48
  tail call void @sdsfree(ptr noundef %428) #11
  %429 = getelementptr inbounds i8, ptr %.0570799, i64 64
  %430 = getelementptr inbounds i8, ptr %.0570799, i64 72
  %431 = load ptr, ptr %430, align 8, !tbaa !76
  %432 = icmp eq ptr %431, null
  br i1 %432, label %433, label %442

433:                                              ; preds = %418
  %434 = getelementptr inbounds i8, ptr %.0570799, i64 80
  %435 = load ptr, ptr %434, align 8, !tbaa !58
  %436 = icmp eq ptr %435, null
  br i1 %436, label %437, label %442

437:                                              ; preds = %433
  %438 = getelementptr inbounds i8, ptr %.7801, i64 64
  %439 = load ptr, ptr %438, align 8, !tbaa !32
  %440 = load ptr, ptr %439, align 8, !tbaa !37
  tail call void @free(ptr noundef %440) #11
  %441 = load ptr, ptr %438, align 8, !tbaa !32
  tail call void @free(ptr noundef %441) #11
  br label %494

442:                                              ; preds = %433, %418
  %443 = getelementptr inbounds i8, ptr %.7801, i64 64
  %444 = load ptr, ptr %443, align 8, !tbaa !32
  %445 = getelementptr inbounds i8, ptr %444, i64 24
  %446 = load ptr, ptr %445, align 8, !tbaa !53
  %447 = icmp eq ptr %429, %446
  br i1 %447, label %448, label %452

448:                                              ; preds = %442
  %449 = getelementptr inbounds i8, ptr %444, i64 32
  %450 = load i64, ptr %449, align 8, !tbaa !40
  %451 = getelementptr inbounds i8, ptr %431, i64 %450
  store ptr %451, ptr %445, align 8, !tbaa !53
  br label %452

452:                                              ; preds = %448, %442
  %453 = getelementptr inbounds i8, ptr %.0570799, i64 80
  %454 = load ptr, ptr %453, align 8, !tbaa !58
  br i1 %432, label %460, label %455

455:                                              ; preds = %452
  %456 = getelementptr inbounds i8, ptr %444, i64 32
  %457 = load i64, ptr %456, align 8, !tbaa !40
  %458 = getelementptr inbounds i8, ptr %431, i64 %457
  %459 = getelementptr inbounds i8, ptr %458, i64 16
  store ptr %454, ptr %459, align 8, !tbaa !58
  br label %460

460:                                              ; preds = %452, %455
  %.8 = phi ptr [ %.7801, %455 ], [ %454, %452 ]
  %.not678 = icmp eq ptr %454, null
  %.phi.trans.insert = getelementptr inbounds i8, ptr %.8, i64 64
  %.pre813 = load ptr, ptr %.phi.trans.insert, align 8, !tbaa !32
  br i1 %.not678, label %._crit_edge812, label %461

461:                                              ; preds = %460
  %462 = getelementptr inbounds i8, ptr %.pre813, i64 32
  %463 = load i64, ptr %462, align 8, !tbaa !40
  %464 = getelementptr inbounds i8, ptr %454, i64 %463
  %465 = getelementptr inbounds i8, ptr %464, i64 8
  store ptr %431, ptr %465, align 8, !tbaa !76
  br label %._crit_edge812

._crit_edge812:                                   ; preds = %460, %461
  %466 = getelementptr inbounds i8, ptr %.0570799, i64 116
  %467 = load i32, ptr %466, align 4, !tbaa !68
  %468 = getelementptr inbounds i8, ptr %.pre813, i64 8
  %469 = load i32, ptr %468, align 8, !tbaa !35
  %470 = add i32 %469, -1
  %471 = and i32 %470, %467
  %472 = load ptr, ptr %.pre813, align 8, !tbaa !37
  %473 = zext i32 %471 to i64
  %474 = getelementptr inbounds %struct.UT_hash_bucket, ptr %472, i64 %473
  %475 = getelementptr inbounds i8, ptr %474, i64 8
  %476 = load i32, ptr %475, align 8, !tbaa !60
  %477 = add i32 %476, -1
  store i32 %477, ptr %475, align 8, !tbaa !60
  %478 = load ptr, ptr %474, align 8, !tbaa !38
  %479 = icmp eq ptr %478, %429
  br i1 %479, label %480, label %483

480:                                              ; preds = %._crit_edge812
  %481 = getelementptr inbounds i8, ptr %.0570799, i64 96
  %482 = load ptr, ptr %481, align 8, !tbaa !67
  store ptr %482, ptr %474, align 8, !tbaa !38
  br label %483

483:                                              ; preds = %480, %._crit_edge812
  %484 = getelementptr inbounds i8, ptr %.0570799, i64 88
  %485 = load ptr, ptr %484, align 8, !tbaa !62
  %.not679 = icmp eq ptr %485, null
  %.phi.trans.insert815 = getelementptr inbounds i8, ptr %.0570799, i64 96
  %.pre816 = load ptr, ptr %.phi.trans.insert815, align 8, !tbaa !67
  br i1 %.not679, label %._crit_edge814, label %486

486:                                              ; preds = %483
  %487 = getelementptr inbounds i8, ptr %485, i64 32
  store ptr %.pre816, ptr %487, align 8, !tbaa !67
  br label %._crit_edge814

._crit_edge814:                                   ; preds = %483, %486
  %.not680 = icmp eq ptr %.pre816, null
  br i1 %.not680, label %490, label %488

488:                                              ; preds = %._crit_edge814
  %489 = getelementptr inbounds i8, ptr %.pre816, i64 24
  store ptr %485, ptr %489, align 8, !tbaa !62
  br label %490

490:                                              ; preds = %488, %._crit_edge814
  %491 = getelementptr inbounds i8, ptr %.pre813, i64 16
  %492 = load i32, ptr %491, align 8, !tbaa !59
  %493 = add i32 %492, -1
  store i32 %493, ptr %491, align 8, !tbaa !59
  br label %494

494:                                              ; preds = %490, %437
  %.9 = phi ptr [ null, %437 ], [ %.8, %490 ]
  tail call void @free(ptr noundef nonnull %.0570799) #11
  %.not681 = icmp eq ptr %.0569800, null
  br i1 %.not681, label %._crit_edge804, label %418, !llvm.loop !80

._crit_edge804:                                   ; preds = %494, %.thread722, %.thread831
  %495 = load i64, ptr %2, align 8, !tbaa !5
  %496 = icmp eq i64 %495, 0
  ret i1 %496
}

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

declare ptr @sdscatprintf(ptr noundef, ptr noundef, ...) local_unnamed_addr #2

declare ptr @sdsempty() local_unnamed_addr #2

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

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

declare ptr @sdsdup(ptr noundef) local_unnamed_addr #2

; Function Attrs: mustprogress 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) #4

; Function Attrs: mustprogress nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite)
declare noalias noundef ptr @malloc(i64 noundef) local_unnamed_addr #5

; Function Attrs: noreturn nounwind
declare void @exit(i32 noundef) local_unnamed_addr #6

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

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

; Function Attrs: nounwind uwtable
declare hidden i32 @gpos_cursive_by_from_id(ptr noundef, ptr noundef) local_unnamed_addr #0

declare void @sdsfree(ptr noundef) local_unnamed_addr #2

; Function Attrs: nofree nounwind willreturn memory(argmem: read)
declare i32 @bcmp(ptr nocapture, ptr nocapture, i64) local_unnamed_addr #9

; Function Attrs: nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite)
declare noalias noundef ptr @calloc(i64 noundef, i64 noundef) local_unnamed_addr #10

attributes #0 = { 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 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
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 = { 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 #4 = { mustprogress nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #5 = { mustprogress nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(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 #6 = { noreturn 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 #7 = { mustprogress nocallback nofree nounwind willreturn memory(argmem: write) }
attributes #8 = { 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 #9 = { nofree nounwind willreturn memory(argmem: read) }
attributes #10 = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite) "alloc-family"="malloc" }
attributes #11 = { nounwind }
attributes #12 = { nounwind allocsize(0) }
attributes #13 = { noreturn 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, !7, i64 0}
!6 = !{!"", !7, i64 0, !7, i64 8, !10, i64 16}
!7 = !{!"long", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!"any pointer", !8, i64 0}
!11 = !{!12, !10, i64 88}
!12 = !{!"otfcc_GlyphOrderPackage", !10, i64 0, !10, i64 8, !10, i64 16, !10, i64 24, !10, i64 32, !10, i64 40, !10, i64 48, !10, i64 56, !10, i64 64, !10, i64 72, !10, i64 80, !10, i64 88, !10, i64 96}
!13 = !{!14, !10, i64 96}
!14 = !{!"__caryll_vectorinterface_subtable_gpos_cursive", !10, i64 0, !10, i64 8, !10, i64 16, !10, i64 24, !10, i64 32, !10, i64 40, !10, i64 48, !10, i64 56, !10, i64 64, !10, i64 72, !10, i64 80, !10, i64 88, !10, i64 96, !10, i64 104, !10, i64 112, !10, i64 120, !10, i64 128, !10, i64 136, !10, i64 144}
!15 = !{!16, !10, i64 264}
!16 = !{!"_caryll_font", !17, i64 0, !10, i64 8, !10, i64 16, !10, i64 24, !10, i64 32, !10, i64 40, !10, i64 48, !10, i64 56, !10, i64 64, !10, i64 72, !10, i64 80, !10, i64 88, !10, i64 96, !10, i64 104, !10, i64 112, !10, i64 120, !10, i64 128, !10, i64 136, !10, i64 144, !10, i64 152, !10, i64 160, !10, i64 168, !10, i64 176, !10, i64 184, !10, i64 192, !10, i64 200, !10, i64 208, !10, i64 216, !10, i64 224, !10, i64 232, !10, i64 240, !10, i64 248, !10, i64 256, !10, i64 264}
!17 = !{!"int", !8, i64 0}
!18 = !{!6, !10, i64 16}
!19 = !{!20, !10, i64 32}
!20 = !{!"", !21, i64 0, !21, i64 1, !21, i64 2, !21, i64 3, !21, i64 4, !21, i64 5, !21, i64 6, !21, i64 7, !21, i64 8, !21, i64 9, !21, i64 10, !21, i64 11, !21, i64 12, !21, i64 13, !21, i64 14, !21, i64 15, !21, i64 16, !21, i64 17, !21, i64 18, !21, i64 19, !21, i64 20, !21, i64 21, !21, i64 22, !10, i64 24, !10, i64 32}
!21 = !{!"_Bool", !8, i64 0}
!22 = !{!23, !10, i64 48}
!23 = !{!"otfcc_ILogger", !10, i64 0, !10, i64 8, !10, i64 16, !10, i64 24, !10, i64 32, !10, i64 40, !10, i64 48, !10, i64 56, !10, i64 64, !10, i64 72, !10, i64 80, !10, i64 88}
!24 = !{!25, !10, i64 8}
!25 = !{!"", !26, i64 0, !28, i64 16, !28, i64 40}
!26 = !{!"otfcc_Handle", !17, i64 0, !27, i64 4, !10, i64 8}
!27 = !{!"short", !8, i64 0}
!28 = !{!"", !21, i64 0, !29, i64 8, !29, i64 16}
!29 = !{!"double", !8, i64 0}
!30 = !{!25, !27, i64 4}
!31 = !{!17, !17, i64 0}
!32 = !{!33, !10, i64 64}
!33 = !{!"", !17, i64 0, !10, i64 8, !28, i64 16, !28, i64 40, !34, i64 64}
!34 = !{!"UT_hash_handle", !10, i64 0, !10, i64 8, !10, i64 16, !10, i64 24, !10, i64 32, !10, i64 40, !17, i64 48, !17, i64 52}
!35 = !{!36, !17, i64 8}
!36 = !{!"UT_hash_table", !10, i64 0, !17, i64 8, !17, i64 12, !17, i64 16, !10, i64 24, !7, i64 32, !17, i64 40, !17, i64 44, !17, i64 48, !17, i64 52, !17, i64 56}
!37 = !{!36, !10, i64 0}
!38 = !{!39, !10, i64 0}
!39 = !{!"UT_hash_bucket", !10, i64 0, !17, i64 8, !17, i64 12}
!40 = !{!36, !7, i64 32}
!41 = !{!33, !17, i64 116}
!42 = !{!33, !17, i64 112}
!43 = !{!33, !10, i64 104}
!44 = !{!33, !10, i64 96}
!45 = distinct !{!45, !46}
!46 = !{!"llvm.loop.mustprogress"}
!47 = !{!33, !17, i64 0}
!48 = !{!33, !10, i64 8}
!49 = !{i64 0, i64 1, !50, i64 8, i64 8, !51, i64 16, i64 8, !51}
!50 = !{!21, !21, i64 0}
!51 = !{!29, !29, i64 0}
!52 = !{!8, !8, i64 0}
!53 = !{!36, !10, i64 24}
!54 = !{!36, !17, i64 12}
!55 = !{!36, !17, i64 56}
!56 = !{!33, !10, i64 80}
!57 = !{!33, !10, i64 72}
!58 = !{!34, !10, i64 16}
!59 = !{!36, !17, i64 16}
!60 = !{!39, !17, i64 8}
!61 = !{!33, !10, i64 88}
!62 = !{!34, !10, i64 24}
!63 = !{!39, !17, i64 12}
!64 = !{!36, !17, i64 52}
!65 = !{!36, !17, i64 40}
!66 = !{!36, !17, i64 44}
!67 = !{!34, !10, i64 32}
!68 = !{!34, !17, i64 52}
!69 = distinct !{!69, !46}
!70 = distinct !{!70, !46}
!71 = !{!36, !17, i64 48}
!72 = distinct !{!72, !46}
!73 = distinct !{!73, !46}
!74 = distinct !{!74, !46}
!75 = distinct !{!75, !46}
!76 = !{!34, !10, i64 8}
!77 = !{!14, !10, i64 104}
!78 = !{!79, !10, i64 80}
!79 = !{!"otfcc_HandlePackage", !10, i64 0, !10, i64 8, !10, i64 16, !10, i64 24, !10, i64 32, !10, i64 40, !10, i64 48, !10, i64 56, !10, i64 64, !10, i64 72, !10, i64 80, !10, i64 88}
!80 = distinct !{!80, !46}


; Effective O3 passes: BDCEPass,CorrelatedValuePropagationPass,DSEPass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferFunctionAttrsPass,InstCombinePass,InstSimplifyPass,JumpThreadingPass,LCSSAPass,LICMPass,LoopInstSimplifyPass,LoopRotatePass,LoopSimplifyPass,LoopUnrollPass,MemCpyOptPass,PostOrderFunctionAttrsPass,ReassociatePass,SCCPPass,SROAPass,SimplifyCFGPass,TailCallElimPass