; LLVM IR from erthink/libmdbx :: src (tree-ops)

; 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.libmdbx_globals = type { %union.bin128, i32, i32, i8, i8, i8, i8, i32, %union.logger_union, %union.pthread_mutex_t, i64, ptr }
%union.bin128 = type { %struct.anon.6 }
%struct.anon.6 = type { i64, i64 }
%union.logger_union = type { ptr }
%union.pthread_mutex_t = type { %struct.__pthread_mutex_s }
%struct.__pthread_mutex_s = type { i32, i32, i32, i32, i32, i16, i16, %struct.__pthread_internal_list }
%struct.__pthread_internal_list = type { ptr, ptr }
%struct.iovec = type { ptr, i64 }
%struct.page_get_result = type { ptr, i32 }
%struct.cursor_couple = type { %struct.MDBX_cursor, ptr, %struct.inner_cursor }
%struct.MDBX_cursor = type { i32, %union.anon.8, i8, i8, ptr, ptr, ptr, ptr, ptr, [32 x ptr], [32 x i16], ptr, ptr }
%union.anon.8 = type { i16 }
%struct.inner_cursor = type { %struct.MDBX_cursor, %struct.tree }
%struct.tree = type { i16, i16, i32, i32, i32, i32, i32, i64, i64, i64 }
%struct.MDBX_txn = type { i32, i32, i64, i64, ptr, ptr, %struct.geo, i64, i64, ptr, ptr, ptr, ptr, ptr, ptr, %struct.MDBX_canary, ptr, %union.anon.12 }
%struct.geo = type { i16, i16, i32, i32, %union.anon.10, %union.anon.11 }
%union.anon.10 = type { i32 }
%union.anon.11 = type { i32 }
%struct.MDBX_canary = type { i64, i64, i64, i64 }
%union.anon.12 = type { %struct.anon.14 }
%struct.anon.14 = type { %struct.troika, ptr, %struct.anon.15, i8, i32, i32, i64, ptr, ptr, ptr, i64, %union.anon.16 }
%struct.troika = type { i8, i8, i8, i8, i32, [3 x i64] }
%struct.anon.15 = type { %struct.MDBX_rkl, i64, %struct.MDBX_rkl }
%struct.MDBX_rkl = type { i64, i64, i32, i32, ptr, [12 x i64] }
%union.anon.16 = type { %struct.anon.17 }
%struct.anon.17 = type { i64, ptr }
%struct.anon.9 = type { i8, i8 }
%struct.page = type <{ i64, i16, i16, %union.anon.18, i32, [0 x i16] }>
%union.anon.18 = type { i32 }
%struct.clc2 = type { %struct.clc, %struct.clc }
%struct.clc = type { ptr, i64, i64 }
%struct.anon.19 = type { i16, i16 }
%struct.MDBX_env = type { %union.mdbx_atomic_uint32_t, i32, i32, %struct.osal_mmap, i32, i32, %struct.osal_mmap, ptr, i16, i16, i16, i16, i16, i16, %union.mdbx_atomic_uint32_t, i8, i8, i16, i32, i32, i32, i32, %struct.anon, ptr, ptr, ptr, ptr, ptr, i32, i32, i32, ptr, ptr, i64, %struct.anon.0, %struct.anon.4, i8, ptr, ptr, ptr, %struct.anon.5, %union.pthread_mutex_t, i32, i32, ptr, %struct.osal_ioring, %union.pthread_mutex_t, [71 x %union.mdbx_atomic_uint64_t] }
%struct.osal_mmap = type { %union.anon, i32, i64, i64, i64 }
%union.anon = type { ptr }
%union.mdbx_atomic_uint32_t = type { i32 }
%struct.anon = type { ptr, ptr, ptr, ptr }
%struct.anon.0 = type { i32, i32, i32, i32, i64, i8, i8, i8, i8, i32, i32, i8, i8, i8, %struct.anon.1, %union.anon.2 }
%struct.anon.1 = type { i16, i16, i16, i16 }
%union.anon.2 = type { i32 }
%struct.anon.4 = type { i64, i64, i64, i64, i64 }
%struct.anon.5 = type { i64 }
%struct.osal_ioring = type { i32, i32, i32, ptr, ptr, ptr }
%union.mdbx_atomic_uint64_t = type { i64 }
%struct.shared_lck = type { i64, i32, %union.mdbx_atomic_uint32_t, %union.mdbx_atomic_uint32_t, %union.mdbx_atomic_uint32_t, %union.mdbx_atomic_uint64_t, %union.mdbx_atomic_uint64_t, [2 x %union.mdbx_atomic_uint32_t], [16 x i8], %struct.pgops, [16 x i8], %union.pthread_mutex_t, %union.mdbx_atomic_uint64_t, %union.mdbx_atomic_uint64_t, %union.mdbx_atomic_uint64_t, %union.mdbx_atomic_uint64_t, %union.mdbx_atomic_uint32_t, i32, %struct.anon.23, %union.pthread_mutex_t, %union.mdbx_atomic_uint32_t, %union.mdbx_atomic_uint32_t, [16 x i8], [0 x %struct.reader_slot] }
%struct.pgops = type { %union.mdbx_atomic_uint64_t, %union.mdbx_atomic_uint64_t, %union.mdbx_atomic_uint64_t, %union.mdbx_atomic_uint64_t, %union.mdbx_atomic_uint64_t, %union.mdbx_atomic_uint64_t, %union.mdbx_atomic_uint64_t, %union.mdbx_atomic_uint64_t, %union.mdbx_atomic_uint64_t, %union.mdbx_atomic_uint64_t, %union.mdbx_atomic_uint64_t, %union.mdbx_atomic_uint64_t, %union.mdbx_atomic_uint32_t, %union.mdbx_atomic_uint32_t, %struct.anon.21 }
%struct.anon.21 = type { %struct.gc_prof_stat, %struct.gc_prof_stat, i32, i32, i32, i32, i32 }
%struct.gc_prof_stat = type { i64, i64, i32, i32, i32, i32, %struct.anon.22 }
%struct.anon.22 = type { i64, i64, i32 }
%struct.anon.23 = type { [4 x i32], [4 x i64] }
%struct.reader_slot = type { %union.mdbx_atomic_uint64_t, %union.mdbx_atomic_uint64_t, %union.mdbx_atomic_uint32_t, %union.mdbx_atomic_uint32_t, %union.mdbx_atomic_uint64_t }

@globals = external global %struct.libmdbx_globals, align 8
@.str.9 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.10 = external hidden unnamed_addr constant [7 x i8], align 1
@.str.38 = external hidden unnamed_addr constant [30 x i8], align 1
@__func__.page_split = external hidden unnamed_addr constant [11 x i8], align 1
@.str.39 = external hidden unnamed_addr constant [66 x i8], align 1
@.str.40 = external hidden unnamed_addr constant [25 x i8], align 1
@.str.41 = external hidden unnamed_addr constant [22 x i8], align 1
@.str.42 = external hidden unnamed_addr constant [21 x i8], align 1
@.str.43 = external hidden unnamed_addr constant [27 x i8], align 1
@.str.44 = external hidden unnamed_addr constant [26 x i8], align 1
@.str.45 = external hidden unnamed_addr constant [59 x i8], align 1
@.str.46 = external hidden unnamed_addr constant [30 x i8], align 1
@.str.47 = external hidden unnamed_addr constant [36 x i8], align 1
@.str.48 = external hidden unnamed_addr constant [114 x i8], align 1
@.str.49 = external hidden unnamed_addr constant [47 x i8], align 1
@.str.50 = external hidden unnamed_addr constant [43 x i8], align 1
@.str.51 = external hidden unnamed_addr constant [12 x i8], align 1
@.str.52 = external hidden unnamed_addr constant [56 x i8], align 1
@.str.53 = external hidden unnamed_addr constant [54 x i8], align 1
@.str.54 = external hidden unnamed_addr constant [12 x i8], align 1
@.str.55 = external hidden unnamed_addr constant [48 x i8], align 1
@.str.56 = external hidden unnamed_addr constant [32 x i8], align 1
@.str.57 = external hidden unnamed_addr constant [19 x i8], align 1
@.str.58 = external hidden unnamed_addr constant [33 x i8], align 1
@.str.59 = external hidden unnamed_addr constant [37 x i8], align 1
@.str.60 = external hidden unnamed_addr constant [31 x i8], align 1
@.str.61 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.62 = external hidden unnamed_addr constant [43 x i8], align 1
@.str.63 = external hidden unnamed_addr constant [36 x i8], align 1
@.str.64 = external hidden unnamed_addr constant [52 x i8], align 1
@.str.65 = external hidden unnamed_addr constant [47 x i8], align 1
@.str.66 = external hidden unnamed_addr constant [40 x i8], align 1
@.str.67 = external hidden unnamed_addr constant [25 x i8], align 1
@.str.68 = external hidden unnamed_addr constant [60 x i8], align 1
@.str.69 = external hidden unnamed_addr constant [59 x i8], align 1
@.str.70 = external hidden unnamed_addr constant [75 x i8], align 1
@.str.71 = external hidden unnamed_addr constant [11 x i8], align 1
@.str.72 = external hidden unnamed_addr constant [52 x i8], align 1
@.str.73 = external hidden unnamed_addr constant [12 x i8], align 1
@.str.74 = external hidden unnamed_addr constant [23 x i8], align 1
@.str.75 = external hidden unnamed_addr constant [42 x i8], align 1
@.str.76 = external hidden unnamed_addr constant [35 x i8], align 1
@.str.77 = external hidden unnamed_addr constant [11 x i8], align 1
@.str.78 = external hidden unnamed_addr constant [43 x i8], align 1
@.str.79 = external hidden unnamed_addr constant [43 x i8], align 1
@.str.80 = external hidden unnamed_addr constant [40 x i8], align 1
@.str.81 = external hidden unnamed_addr constant [72 x i8], align 1
@.str.82 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.83 = external hidden unnamed_addr constant [85 x i8], align 1
@.str.84 = external hidden unnamed_addr constant [50 x i8], align 1
@.str.85 = external hidden unnamed_addr constant [50 x i8], align 1
@.str.86 = external hidden unnamed_addr constant [45 x i8], align 1
@.str.87 = external hidden unnamed_addr constant [45 x i8], align 1
@.str.88 = external hidden unnamed_addr constant [62 x i8], align 1
@.str.89 = external hidden unnamed_addr constant [55 x i8], align 1
@.str.90 = external hidden unnamed_addr constant [61 x i8], align 1
@.str.91 = external hidden unnamed_addr constant [56 x i8], align 1
@.str.92 = external hidden unnamed_addr constant [40 x i8], align 1
@.str.93 = external hidden unnamed_addr constant [38 x i8], align 1
@.str.94 = external hidden unnamed_addr constant [20 x i8], align 1
@.str.95 = external hidden unnamed_addr constant [59 x i8], align 1
@.str.96 = external hidden unnamed_addr constant [35 x i8], align 1
@.str.97 = external hidden unnamed_addr constant [21 x i8], align 1
@.str.98 = external hidden unnamed_addr constant [10 x i8], align 1
@.str.99 = external hidden unnamed_addr constant [20 x i8], align 1
@.str.100 = external hidden unnamed_addr constant [18 x i8], align 1
@.str.101 = external hidden unnamed_addr constant [36 x i8], align 1
@.str.102 = external hidden unnamed_addr constant [25 x i8], align 1
@.str.103 = external hidden unnamed_addr constant [40 x i8], align 1
@.str.104 = external hidden unnamed_addr constant [18 x i8], align 1

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

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden i64 @page_space(ptr noundef) #1

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(none)
declare i64 @llvm.expect.i64(i64, i64) #2

; Function Attrs: noreturn
declare void @mdbx_assert_fail(ptr noundef, ptr noundef, ptr noundef, i32 noundef) #3

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

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden i64 @page_numkeys(ptr noundef) #1

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden zeroext i1 @is_leaf(ptr noundef) #1

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden ptr @page_node(ptr noundef, i64 noundef) #1

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden zeroext i8 @node_flags(ptr noalias noundef) #1

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden i32 @node_pgno(ptr noalias noundef) #1

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden zeroext i8 @page_type(ptr noundef) #1

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden i64 @page_room(ptr noundef) #1

declare void @debug_log(i32 noundef, ptr noundef, i32 noundef, ptr noundef, ...) #4

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden i64 @page_used(ptr noundef, ptr noundef) #1

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden i64 @cursor_dbi(ptr noundef) #1

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden zeroext i1 @is_branch(ptr noundef) #1

; Function Attrs: nounwind uwtable
declare hidden ptr @cursor_clone(ptr noundef, ptr noundef) #5

declare i32 @cursor_validate_updating(ptr noundef) #4

; Function Attrs: nounwind uwtable
define dso_local i32 @page_split(ptr noundef %0, ptr noundef %1, ptr noundef %2, i32 noundef %3, i32 noundef %4) #5 {
  %6 = alloca i32, align 4
  %7 = alloca ptr, align 8
  %8 = alloca ptr, align 8
  %9 = alloca ptr, align 8
  %10 = alloca i32, align 4
  %11 = alloca i32, align 4
  %12 = alloca i32, align 4
  %13 = alloca i32, align 4
  %14 = alloca i32, align 4
  %15 = alloca ptr, align 8
  %16 = alloca %struct.iovec, align 8
  %17 = alloca %struct.iovec, align 8
  %18 = alloca ptr, align 8
  %19 = alloca [510 x i8], align 16
  %20 = alloca ptr, align 8
  %21 = alloca i64, align 8
  %22 = alloca i64, align 8
  %23 = alloca i32, align 4
  %24 = alloca i64, align 8
  %25 = alloca %struct.page_get_result, align 8
  %26 = alloca ptr, align 8
  %27 = alloca i64, align 8
  %28 = alloca %struct.page_get_result, align 8
  %29 = alloca ptr, align 8
  %30 = alloca %struct.cursor_couple, align 8
  %31 = alloca ptr, align 8
  %32 = alloca i64, align 8
  %33 = alloca %struct.iovec, align 8
  %34 = alloca i64, align 8
  %35 = alloca %struct.iovec, align 8
  %36 = alloca %struct.iovec, align 8
  %37 = alloca %struct.iovec, align 8
  %38 = alloca i8, align 1
  %39 = alloca i8, align 1
  %40 = alloca i64, align 8
  %41 = alloca i64, align 8
  %42 = alloca ptr, align 8
  %43 = alloca i64, align 8
  %44 = alloca i64, align 8
  %45 = alloca ptr, align 8
  %46 = alloca ptr, align 8
  %47 = alloca i64, align 8
  %48 = alloca i64, align 8
  %49 = alloca i64, align 8
  %50 = alloca i64, align 8
  %51 = alloca i64, align 8
  %52 = alloca i64, align 8
  %53 = alloca i64, align 8
  %54 = alloca i64, align 8
  %55 = alloca i64, align 8
  %56 = alloca i64, align 8
  %57 = alloca i64, align 8
  %58 = alloca ptr, align 8
  %59 = alloca i64, align 8
  %60 = alloca i64, align 8
  %61 = alloca ptr, align 8
  %62 = alloca i8, align 1
  %63 = alloca i32, align 4
  %64 = alloca i32, align 4
  %65 = alloca i64, align 8
  %66 = alloca ptr, align 8
  %67 = alloca ptr, align 8
  %68 = alloca ptr, align 8
  %69 = alloca i64, align 8
  %70 = alloca i64, align 8
  %71 = alloca %struct.iovec, align 8
  %72 = alloca i64, align 8
  %73 = alloca i64, align 8
  %74 = alloca i32, align 4
  %75 = alloca ptr, align 8
  %76 = alloca ptr, align 8
  %77 = alloca i64, align 8
  %78 = alloca i64, align 8
  %79 = alloca i64, align 8
  %80 = alloca ptr, align 8
  %81 = alloca ptr, align 8
  %82 = alloca i64, align 8
  %83 = alloca i64, align 8
  %84 = alloca ptr, align 8
  store ptr %0, ptr %7, align 8, !tbaa !5
  store ptr %1, ptr %8, align 8, !tbaa !5
  store ptr %2, ptr %9, align 8, !tbaa !5
  store i32 %3, ptr %10, align 4, !tbaa !9
  store i32 %4, ptr %11, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %12) #10
  call void @llvm.lifetime.start.p0(i64 4, ptr %13) #10
  store i32 0, ptr %13, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %14) #10
  store i32 0, ptr %14, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %15) #10
  %85 = load ptr, ptr %7, align 8, !tbaa !5
  %86 = getelementptr inbounds %struct.MDBX_cursor, ptr %85, i32 0, i32 5
  %87 = load ptr, ptr %86, align 8, !tbaa !11
  %88 = getelementptr inbounds %struct.MDBX_txn, ptr %87, i32 0, i32 9
  %89 = load ptr, ptr %88, align 8, !tbaa !13
  store ptr %89, ptr %15, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 16, ptr %16) #10
  call void @llvm.lifetime.start.p0(i64 16, ptr %17) #10
  call void @llvm.lifetime.start.p0(i64 8, ptr %18) #10
  store ptr null, ptr %18, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 510, ptr %19) #10
  call void @llvm.lifetime.start.p0(i64 8, ptr %20) #10
  %90 = load ptr, ptr %7, align 8, !tbaa !5
  %91 = getelementptr inbounds %struct.MDBX_cursor, ptr %90, i32 0, i32 9
  %92 = load ptr, ptr %7, align 8, !tbaa !5
  %93 = getelementptr inbounds %struct.MDBX_cursor, ptr %92, i32 0, i32 1
  %94 = getelementptr inbounds %struct.anon.9, ptr %93, i32 0, i32 1
  %95 = load i8, ptr %94, align 1, !tbaa !19
  %96 = sext i8 %95 to i64
  %97 = getelementptr inbounds [32 x ptr], ptr %91, i64 0, i64 %96
  %98 = load ptr, ptr %97, align 8, !tbaa !5
  store ptr %98, ptr %20, align 8, !tbaa !5
  br label %99

99:                                               ; preds = %5
  %100 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %101 = zext i8 %100 to i32
  %102 = and i32 %101, 1
  %103 = icmp ne i32 %102, 0
  %104 = xor i1 %103, true
  %105 = xor i1 %104, true
  %106 = zext i1 %105 to i32
  %107 = sext i32 %106 to i64
  %108 = call i64 @llvm.expect.i64(i64 %107, i64 1)
  %109 = icmp ne i64 %108, 0
  br i1 %109, label %110, label %134

110:                                              ; preds = %99
  br label %111

111:                                              ; preds = %110
  %112 = load ptr, ptr %20, align 8, !tbaa !5
  %113 = getelementptr inbounds %struct.page, ptr %112, i32 0, i32 2
  %114 = load i16, ptr %113, align 1, !tbaa !23
  %115 = zext i16 %114 to i32
  %116 = and i32 %115, 57304
  %117 = icmp eq i32 %116, 0
  %118 = xor i1 %117, true
  %119 = xor i1 %118, true
  %120 = xor i1 %119, true
  %121 = zext i1 %120 to i32
  %122 = sext i32 %121 to i64
  %123 = call i64 @llvm.expect.i64(i64 %122, i64 0)
  %124 = icmp ne i64 %123, 0
  br i1 %124, label %125, label %131

125:                                              ; preds = %111
  %126 = load ptr, ptr %7, align 8, !tbaa !5
  %127 = getelementptr inbounds %struct.MDBX_cursor, ptr %126, i32 0, i32 5
  %128 = load ptr, ptr %127, align 8, !tbaa !11
  %129 = getelementptr inbounds %struct.MDBX_txn, ptr %128, i32 0, i32 9
  %130 = load ptr, ptr %129, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %130, ptr noundef @.str.38, ptr noundef @__func__.page_split, i32 noundef 945) #11
  unreachable

131:                                              ; preds = %111
  br label %132

132:                                              ; preds = %131
  br label %133

133:                                              ; preds = %132
  br label %134

134:                                              ; preds = %133, %99
  br label %135

135:                                              ; preds = %134
  br label %136

136:                                              ; preds = %135
  call void @llvm.lifetime.start.p0(i64 8, ptr %21) #10
  %137 = load ptr, ptr %7, align 8, !tbaa !5
  %138 = getelementptr inbounds %struct.MDBX_cursor, ptr %137, i32 0, i32 10
  %139 = load ptr, ptr %7, align 8, !tbaa !5
  %140 = getelementptr inbounds %struct.MDBX_cursor, ptr %139, i32 0, i32 1
  %141 = getelementptr inbounds %struct.anon.9, ptr %140, i32 0, i32 1
  %142 = load i8, ptr %141, align 1, !tbaa !19
  %143 = sext i8 %142 to i64
  %144 = getelementptr inbounds [32 x i16], ptr %138, i64 0, i64 %143
  %145 = load i16, ptr %144, align 2, !tbaa !23
  %146 = zext i16 %145 to i64
  store i64 %146, ptr %21, align 8, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 8, ptr %22) #10
  %147 = load ptr, ptr %20, align 8, !tbaa !5
  %148 = call i64 @page_numkeys(ptr noundef %147) #12
  store i64 %148, ptr %22, align 8, !tbaa !24
  %149 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %150 = zext i8 %149 to i32
  %151 = and i32 %150, 2
  %152 = icmp ne i32 %151, 0
  %153 = xor i1 %152, true
  %154 = xor i1 %153, true
  %155 = zext i1 %154 to i32
  %156 = sext i32 %155 to i64
  %157 = call i64 @llvm.expect.i64(i64 %156, i64 0)
  %158 = icmp ne i64 %157, 0
  br i1 %158, label %159, label %173

159:                                              ; preds = %136
  %160 = load ptr, ptr %7, align 8, !tbaa !5
  %161 = call i32 @cursor_validate_updating(ptr noundef %160)
  store i32 %161, ptr %13, align 4, !tbaa !9
  %162 = load i32, ptr %13, align 4, !tbaa !9
  %163 = icmp ne i32 %162, 0
  %164 = xor i1 %163, true
  %165 = xor i1 %164, true
  %166 = zext i1 %165 to i32
  %167 = sext i32 %166 to i64
  %168 = call i64 @llvm.expect.i64(i64 %167, i64 0)
  %169 = icmp ne i64 %168, 0
  br i1 %169, label %170, label %172

170:                                              ; preds = %159
  %171 = load i32, ptr %13, align 4, !tbaa !9
  store i32 %171, ptr %6, align 4
  store i32 1, ptr %23, align 4
  br label %4631

172:                                              ; preds = %159
  br label %173

173:                                              ; preds = %172, %136
  call void @llvm.lifetime.start.p0(i64 8, ptr %24) #10
  %174 = load ptr, ptr %20, align 8, !tbaa !5
  %175 = getelementptr inbounds %struct.page, ptr %174, i32 0, i32 2
  %176 = load i16, ptr %175, align 1, !tbaa !23
  %177 = zext i16 %176 to i32
  %178 = and i32 %177, 1
  %179 = sext i32 %178 to i64
  %180 = add i64 %179, 1
  store i64 %180, ptr %24, align 8, !tbaa !24
  br label %181

181:                                              ; preds = %173
  %182 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 5), align 2, !tbaa !25
  %183 = zext i8 %182 to i32
  %184 = icmp sle i32 5, %183
  %185 = xor i1 %184, true
  %186 = xor i1 %185, true
  %187 = zext i1 %186 to i32
  %188 = sext i32 %187 to i64
  %189 = call i64 @llvm.expect.i64(i64 %188, i64 0)
  %190 = icmp ne i64 %189, 0
  br i1 %190, label %191, label %225

191:                                              ; preds = %181
  %192 = load ptr, ptr %20, align 8, !tbaa !5
  %193 = call zeroext i1 @is_leaf(ptr noundef %192) #12
  %194 = zext i1 %193 to i64
  %195 = select i1 %193, ptr @.str.9, ptr @.str.10
  %196 = load ptr, ptr %20, align 8, !tbaa !5
  %197 = getelementptr inbounds %struct.page, ptr %196, i32 0, i32 4
  %198 = load i32, ptr %197, align 1, !tbaa !9
  %199 = load ptr, ptr %8, align 8, !tbaa !5
  %200 = getelementptr inbounds %struct.iovec, ptr %199, i32 0, i32 1
  %201 = load i64, ptr %200, align 8, !tbaa !26
  %202 = load ptr, ptr %9, align 8, !tbaa !5
  %203 = icmp ne ptr %202, null
  br i1 %203, label %204, label %208

204:                                              ; preds = %191
  %205 = load ptr, ptr %9, align 8, !tbaa !5
  %206 = getelementptr inbounds %struct.iovec, ptr %205, i32 0, i32 1
  %207 = load i64, ptr %206, align 8, !tbaa !26
  br label %209

208:                                              ; preds = %191
  br label %209

209:                                              ; preds = %208, %204
  %210 = phi i64 [ %207, %204 ], [ 0, %208 ]
  %211 = load ptr, ptr %8, align 8, !tbaa !5
  %212 = getelementptr inbounds [510 x i8], ptr %19, i64 0, i64 0
  %213 = call ptr @mdbx_dump_val(ptr noundef %211, ptr noundef %212, i64 noundef 255)
  %214 = load ptr, ptr %7, align 8, !tbaa !5
  %215 = getelementptr inbounds %struct.MDBX_cursor, ptr %214, i32 0, i32 10
  %216 = load ptr, ptr %7, align 8, !tbaa !5
  %217 = getelementptr inbounds %struct.MDBX_cursor, ptr %216, i32 0, i32 1
  %218 = getelementptr inbounds %struct.anon.9, ptr %217, i32 0, i32 1
  %219 = load i8, ptr %218, align 1, !tbaa !19
  %220 = sext i8 %219 to i64
  %221 = getelementptr inbounds [32 x i16], ptr %215, i64 0, i64 %220
  %222 = load i16, ptr %221, align 2, !tbaa !23
  %223 = zext i16 %222 to i32
  %224 = load i64, ptr %22, align 8, !tbaa !24
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 5, ptr noundef @__func__.page_split, i32 noundef 958, ptr noundef @.str.39, ptr noundef %195, i32 noundef %198, i64 noundef %201, i64 noundef %210, ptr noundef %213, i32 noundef %223, i64 noundef %224)
  br label %225

225:                                              ; preds = %209, %181
  br label %226

226:                                              ; preds = %225
  br label %227

227:                                              ; preds = %226
  br label %228

228:                                              ; preds = %227
  %229 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %230 = zext i8 %229 to i32
  %231 = and i32 %230, 1
  %232 = icmp ne i32 %231, 0
  %233 = xor i1 %232, true
  %234 = xor i1 %233, true
  %235 = zext i1 %234 to i32
  %236 = sext i32 %235 to i64
  %237 = call i64 @llvm.expect.i64(i64 %236, i64 1)
  %238 = icmp ne i64 %237, 0
  br i1 %238, label %239, label %262

239:                                              ; preds = %228
  br label %240

240:                                              ; preds = %239
  %241 = load i64, ptr %22, align 8, !tbaa !24
  %242 = add i64 %241, 1
  %243 = load i64, ptr %24, align 8, !tbaa !24
  %244 = mul i64 %243, 2
  %245 = icmp uge i64 %242, %244
  %246 = xor i1 %245, true
  %247 = xor i1 %246, true
  %248 = xor i1 %247, true
  %249 = zext i1 %248 to i32
  %250 = sext i32 %249 to i64
  %251 = call i64 @llvm.expect.i64(i64 %250, i64 0)
  %252 = icmp ne i64 %251, 0
  br i1 %252, label %253, label %259

253:                                              ; preds = %240
  %254 = load ptr, ptr %7, align 8, !tbaa !5
  %255 = getelementptr inbounds %struct.MDBX_cursor, ptr %254, i32 0, i32 5
  %256 = load ptr, ptr %255, align 8, !tbaa !11
  %257 = getelementptr inbounds %struct.MDBX_txn, ptr %256, i32 0, i32 9
  %258 = load ptr, ptr %257, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %258, ptr noundef @.str.40, ptr noundef @__func__.page_split, i32 noundef 959) #11
  unreachable

259:                                              ; preds = %240
  br label %260

260:                                              ; preds = %259
  br label %261

261:                                              ; preds = %260
  br label %262

262:                                              ; preds = %261, %228
  br label %263

263:                                              ; preds = %262
  br label %264

264:                                              ; preds = %263
  call void @llvm.lifetime.start.p0(i64 16, ptr %25) #10
  %265 = load ptr, ptr %7, align 8, !tbaa !5
  %266 = load ptr, ptr %20, align 8, !tbaa !5
  %267 = getelementptr inbounds %struct.page, ptr %266, i32 0, i32 2
  %268 = load i16, ptr %267, align 1, !tbaa !23
  %269 = zext i16 %268 to i32
  %270 = call { ptr, i32 } @page_new(ptr noundef %265, i32 noundef %269)
  %271 = getelementptr inbounds { ptr, i32 }, ptr %25, i32 0, i32 0
  %272 = extractvalue { ptr, i32 } %270, 0
  store ptr %272, ptr %271, align 8
  %273 = getelementptr inbounds { ptr, i32 }, ptr %25, i32 0, i32 1
  %274 = extractvalue { ptr, i32 } %270, 1
  store i32 %274, ptr %273, align 8
  %275 = getelementptr inbounds %struct.page_get_result, ptr %25, i32 0, i32 1
  %276 = load i32, ptr %275, align 8, !tbaa !28
  %277 = icmp ne i32 %276, 0
  %278 = xor i1 %277, true
  %279 = xor i1 %278, true
  %280 = zext i1 %279 to i32
  %281 = sext i32 %280 to i64
  %282 = call i64 @llvm.expect.i64(i64 %281, i64 0)
  %283 = icmp ne i64 %282, 0
  br i1 %283, label %284, label %287

284:                                              ; preds = %264
  %285 = getelementptr inbounds %struct.page_get_result, ptr %25, i32 0, i32 1
  %286 = load i32, ptr %285, align 8, !tbaa !28
  store i32 %286, ptr %6, align 4
  store i32 1, ptr %23, align 4
  br label %4630

287:                                              ; preds = %264
  call void @llvm.lifetime.start.p0(i64 8, ptr %26) #10
  %288 = getelementptr inbounds %struct.page_get_result, ptr %25, i32 0, i32 0
  %289 = load ptr, ptr %288, align 8, !tbaa !30
  store ptr %289, ptr %26, align 8, !tbaa !5
  %290 = load ptr, ptr %20, align 8, !tbaa !5
  %291 = getelementptr inbounds %struct.page, ptr %290, i32 0, i32 1
  %292 = load i16, ptr %291, align 1, !tbaa !23
  %293 = load ptr, ptr %26, align 8, !tbaa !5
  %294 = getelementptr inbounds %struct.page, ptr %293, i32 0, i32 1
  store i16 %292, ptr %294, align 1, !tbaa !23
  br label %295

295:                                              ; preds = %287
  %296 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 5), align 2, !tbaa !25
  %297 = zext i8 %296 to i32
  %298 = icmp sle i32 5, %297
  %299 = xor i1 %298, true
  %300 = xor i1 %299, true
  %301 = zext i1 %300 to i32
  %302 = sext i32 %301 to i64
  %303 = call i64 @llvm.expect.i64(i64 %302, i64 0)
  %304 = icmp ne i64 %303, 0
  br i1 %304, label %305, label %309

305:                                              ; preds = %295
  %306 = load ptr, ptr %26, align 8, !tbaa !5
  %307 = getelementptr inbounds %struct.page, ptr %306, i32 0, i32 4
  %308 = load i32, ptr %307, align 1, !tbaa !9
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 5, ptr noundef @__func__.page_split, i32 noundef 967, ptr noundef @.str.41, i32 noundef %308)
  br label %309

309:                                              ; preds = %305, %295
  br label %310

310:                                              ; preds = %309
  br label %311

311:                                              ; preds = %310
  call void @llvm.lifetime.start.p0(i64 8, ptr %27) #10
  %312 = load ptr, ptr %7, align 8, !tbaa !5
  %313 = getelementptr inbounds %struct.MDBX_cursor, ptr %312, i32 0, i32 1
  %314 = getelementptr inbounds %struct.anon.9, ptr %313, i32 0, i32 1
  %315 = load i8, ptr %314, align 1, !tbaa !19
  %316 = sext i8 %315 to i32
  %317 = sub nsw i32 %316, 1
  %318 = sext i32 %317 to i64
  store i64 %318, ptr %27, align 8, !tbaa !24
  %319 = load ptr, ptr %7, align 8, !tbaa !5
  %320 = getelementptr inbounds %struct.MDBX_cursor, ptr %319, i32 0, i32 1
  %321 = getelementptr inbounds %struct.anon.9, ptr %320, i32 0, i32 1
  %322 = load i8, ptr %321, align 1, !tbaa !19
  %323 = sext i8 %322 to i32
  %324 = icmp eq i32 %323, 0
  br i1 %324, label %325, label %531

325:                                              ; preds = %311
  call void @llvm.lifetime.start.p0(i64 16, ptr %28) #10
  %326 = load ptr, ptr %7, align 8, !tbaa !5
  %327 = call { ptr, i32 } @page_new(ptr noundef %326, i32 noundef 1)
  %328 = getelementptr inbounds { ptr, i32 }, ptr %28, i32 0, i32 0
  %329 = extractvalue { ptr, i32 } %327, 0
  store ptr %329, ptr %328, align 8
  %330 = getelementptr inbounds { ptr, i32 }, ptr %28, i32 0, i32 1
  %331 = extractvalue { ptr, i32 } %327, 1
  store i32 %331, ptr %330, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %25, ptr align 8 %28, i64 16, i1 false), !tbaa.struct !31
  call void @llvm.lifetime.end.p0(i64 16, ptr %28) #10
  %332 = getelementptr inbounds %struct.page_get_result, ptr %25, i32 0, i32 1
  %333 = load i32, ptr %332, align 8, !tbaa !28
  store i32 %333, ptr %13, align 4, !tbaa !9
  %334 = load i32, ptr %13, align 4, !tbaa !9
  %335 = icmp ne i32 %334, 0
  %336 = xor i1 %335, true
  %337 = xor i1 %336, true
  %338 = zext i1 %337 to i32
  %339 = sext i32 %338 to i64
  %340 = call i64 @llvm.expect.i64(i64 %339, i64 0)
  %341 = icmp ne i64 %340, 0
  br i1 %341, label %342, label %343

342:                                              ; preds = %325
  br label %4523

343:                                              ; preds = %325
  call void @llvm.lifetime.start.p0(i64 8, ptr %29) #10
  %344 = getelementptr inbounds %struct.page_get_result, ptr %25, i32 0, i32 0
  %345 = load ptr, ptr %344, align 8, !tbaa !30
  store ptr %345, ptr %29, align 8, !tbaa !5
  br label %346

346:                                              ; preds = %343
  %347 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %348 = zext i8 %347 to i32
  %349 = and i32 %348, 1
  %350 = icmp ne i32 %349, 0
  %351 = xor i1 %350, true
  %352 = xor i1 %351, true
  %353 = zext i1 %352 to i32
  %354 = sext i32 %353 to i64
  %355 = call i64 @llvm.expect.i64(i64 %354, i64 1)
  %356 = icmp ne i64 %355, 0
  br i1 %356, label %357, label %382

357:                                              ; preds = %346
  br label %358

358:                                              ; preds = %357
  %359 = load ptr, ptr %7, align 8, !tbaa !5
  %360 = getelementptr inbounds %struct.MDBX_cursor, ptr %359, i32 0, i32 6
  %361 = load ptr, ptr %360, align 8, !tbaa !32
  %362 = getelementptr inbounds %struct.tree, ptr %361, i32 0, i32 1
  %363 = load i16, ptr %362, align 2, !tbaa !33
  %364 = zext i16 %363 to i32
  %365 = icmp sgt i32 %364, 0
  %366 = xor i1 %365, true
  %367 = xor i1 %366, true
  %368 = xor i1 %367, true
  %369 = zext i1 %368 to i32
  %370 = sext i32 %369 to i64
  %371 = call i64 @llvm.expect.i64(i64 %370, i64 0)
  %372 = icmp ne i64 %371, 0
  br i1 %372, label %373, label %379

373:                                              ; preds = %358
  %374 = load ptr, ptr %7, align 8, !tbaa !5
  %375 = getelementptr inbounds %struct.MDBX_cursor, ptr %374, i32 0, i32 5
  %376 = load ptr, ptr %375, align 8, !tbaa !11
  %377 = getelementptr inbounds %struct.MDBX_txn, ptr %376, i32 0, i32 9
  %378 = load ptr, ptr %377, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %378, ptr noundef @.str.42, ptr noundef @__func__.page_split, i32 noundef 981) #11
  unreachable

379:                                              ; preds = %358
  br label %380

380:                                              ; preds = %379
  br label %381

381:                                              ; preds = %380
  br label %382

382:                                              ; preds = %381, %346
  br label %383

383:                                              ; preds = %382
  br label %384

384:                                              ; preds = %383
  %385 = load ptr, ptr %7, align 8, !tbaa !5
  %386 = getelementptr inbounds %struct.MDBX_cursor, ptr %385, i32 0, i32 9
  %387 = getelementptr inbounds [32 x ptr], ptr %386, i64 0, i64 0
  %388 = getelementptr inbounds ptr, ptr %387, i64 3
  call void @llvm.memset.p0.i64(ptr align 8 %388, i8 0, i64 232, i1 false)
  %389 = load ptr, ptr %7, align 8, !tbaa !5
  %390 = getelementptr inbounds %struct.MDBX_cursor, ptr %389, i32 0, i32 10
  %391 = getelementptr inbounds [32 x i16], ptr %390, i64 0, i64 0
  %392 = getelementptr inbounds i16, ptr %391, i64 3
  call void @llvm.memset.p0.i64(ptr align 2 %392, i8 -1, i64 58, i1 false)
  %393 = load ptr, ptr %7, align 8, !tbaa !5
  %394 = getelementptr inbounds %struct.MDBX_cursor, ptr %393, i32 0, i32 9
  %395 = getelementptr inbounds [32 x ptr], ptr %394, i64 0, i64 1
  %396 = load ptr, ptr %395, align 8, !tbaa !5
  %397 = load ptr, ptr %7, align 8, !tbaa !5
  %398 = getelementptr inbounds %struct.MDBX_cursor, ptr %397, i32 0, i32 9
  %399 = getelementptr inbounds [32 x ptr], ptr %398, i64 0, i64 2
  store ptr %396, ptr %399, align 8, !tbaa !5
  %400 = load ptr, ptr %7, align 8, !tbaa !5
  %401 = getelementptr inbounds %struct.MDBX_cursor, ptr %400, i32 0, i32 10
  %402 = getelementptr inbounds [32 x i16], ptr %401, i64 0, i64 1
  %403 = load i16, ptr %402, align 2, !tbaa !23
  %404 = load ptr, ptr %7, align 8, !tbaa !5
  %405 = getelementptr inbounds %struct.MDBX_cursor, ptr %404, i32 0, i32 10
  %406 = getelementptr inbounds [32 x i16], ptr %405, i64 0, i64 2
  store i16 %403, ptr %406, align 4, !tbaa !23
  %407 = load ptr, ptr %7, align 8, !tbaa !5
  %408 = getelementptr inbounds %struct.MDBX_cursor, ptr %407, i32 0, i32 9
  %409 = getelementptr inbounds [32 x ptr], ptr %408, i64 0, i64 0
  %410 = load ptr, ptr %409, align 8, !tbaa !5
  %411 = load ptr, ptr %7, align 8, !tbaa !5
  %412 = getelementptr inbounds %struct.MDBX_cursor, ptr %411, i32 0, i32 9
  %413 = getelementptr inbounds [32 x ptr], ptr %412, i64 0, i64 1
  store ptr %410, ptr %413, align 8, !tbaa !5
  %414 = load ptr, ptr %7, align 8, !tbaa !5
  %415 = getelementptr inbounds %struct.MDBX_cursor, ptr %414, i32 0, i32 10
  %416 = getelementptr inbounds [32 x i16], ptr %415, i64 0, i64 0
  %417 = load i16, ptr %416, align 8, !tbaa !23
  %418 = load ptr, ptr %7, align 8, !tbaa !5
  %419 = getelementptr inbounds %struct.MDBX_cursor, ptr %418, i32 0, i32 10
  %420 = getelementptr inbounds [32 x i16], ptr %419, i64 0, i64 1
  store i16 %417, ptr %420, align 2, !tbaa !23
  %421 = load ptr, ptr %29, align 8, !tbaa !5
  %422 = load ptr, ptr %7, align 8, !tbaa !5
  %423 = getelementptr inbounds %struct.MDBX_cursor, ptr %422, i32 0, i32 9
  %424 = getelementptr inbounds [32 x ptr], ptr %423, i64 0, i64 0
  store ptr %421, ptr %424, align 8, !tbaa !5
  %425 = load ptr, ptr %7, align 8, !tbaa !5
  %426 = getelementptr inbounds %struct.MDBX_cursor, ptr %425, i32 0, i32 10
  %427 = getelementptr inbounds [32 x i16], ptr %426, i64 0, i64 0
  store i16 0, ptr %427, align 8, !tbaa !23
  %428 = load ptr, ptr %29, align 8, !tbaa !5
  %429 = getelementptr inbounds %struct.page, ptr %428, i32 0, i32 4
  %430 = load i32, ptr %429, align 1, !tbaa !9
  %431 = load ptr, ptr %7, align 8, !tbaa !5
  %432 = getelementptr inbounds %struct.MDBX_cursor, ptr %431, i32 0, i32 6
  %433 = load ptr, ptr %432, align 8, !tbaa !32
  %434 = getelementptr inbounds %struct.tree, ptr %433, i32 0, i32 3
  store i32 %430, ptr %434, align 4, !tbaa !35
  br label %435

435:                                              ; preds = %384
  %436 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 5), align 2, !tbaa !25
  %437 = zext i8 %436 to i32
  %438 = icmp sle i32 5, %437
  %439 = xor i1 %438, true
  %440 = xor i1 %439, true
  %441 = zext i1 %440 to i32
  %442 = sext i32 %441 to i64
  %443 = call i64 @llvm.expect.i64(i64 %442, i64 0)
  %444 = icmp ne i64 %443, 0
  br i1 %444, label %445, label %449

445:                                              ; preds = %435
  %446 = load ptr, ptr %29, align 8, !tbaa !5
  %447 = getelementptr inbounds %struct.page, ptr %446, i32 0, i32 4
  %448 = load i32, ptr %447, align 1, !tbaa !9
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 5, ptr noundef @__func__.page_split, i32 noundef 993, ptr noundef @.str.43, i32 noundef %448)
  br label %449

449:                                              ; preds = %445, %435
  br label %450

450:                                              ; preds = %449
  br label %451

451:                                              ; preds = %450
  %452 = load ptr, ptr %7, align 8, !tbaa !5
  %453 = getelementptr inbounds %struct.MDBX_cursor, ptr %452, i32 0, i32 6
  %454 = load ptr, ptr %453, align 8, !tbaa !32
  %455 = getelementptr inbounds %struct.tree, ptr %454, i32 0, i32 1
  %456 = load i16, ptr %455, align 2, !tbaa !33
  %457 = add i16 %456, 1
  store i16 %457, ptr %455, align 2, !tbaa !33
  %458 = zext i16 %456 to i32
  store i32 %458, ptr %14, align 4, !tbaa !9
  %459 = load ptr, ptr %7, align 8, !tbaa !5
  %460 = load ptr, ptr %20, align 8, !tbaa !5
  %461 = getelementptr inbounds %struct.page, ptr %460, i32 0, i32 4
  %462 = load i32, ptr %461, align 1, !tbaa !9
  %463 = call i32 @node_add_branch(ptr noundef %459, i64 noundef 0, ptr noundef null, i32 noundef %462)
  store i32 %463, ptr %13, align 4, !tbaa !9
  %464 = load i32, ptr %13, align 4, !tbaa !9
  %465 = icmp ne i32 %464, 0
  %466 = xor i1 %465, true
  %467 = xor i1 %466, true
  %468 = zext i1 %467 to i32
  %469 = sext i32 %468 to i64
  %470 = call i64 @llvm.expect.i64(i64 %469, i64 0)
  %471 = icmp ne i64 %470, 0
  br i1 %471, label %472, label %500

472:                                              ; preds = %451
  %473 = load ptr, ptr %7, align 8, !tbaa !5
  %474 = getelementptr inbounds %struct.MDBX_cursor, ptr %473, i32 0, i32 9
  %475 = getelementptr inbounds [32 x ptr], ptr %474, i64 0, i64 1
  %476 = load ptr, ptr %475, align 8, !tbaa !5
  %477 = load ptr, ptr %7, align 8, !tbaa !5
  %478 = getelementptr inbounds %struct.MDBX_cursor, ptr %477, i32 0, i32 9
  %479 = getelementptr inbounds [32 x ptr], ptr %478, i64 0, i64 0
  store ptr %476, ptr %479, align 8, !tbaa !5
  %480 = load ptr, ptr %7, align 8, !tbaa !5
  %481 = getelementptr inbounds %struct.MDBX_cursor, ptr %480, i32 0, i32 10
  %482 = getelementptr inbounds [32 x i16], ptr %481, i64 0, i64 1
  %483 = load i16, ptr %482, align 2, !tbaa !23
  %484 = load ptr, ptr %7, align 8, !tbaa !5
  %485 = getelementptr inbounds %struct.MDBX_cursor, ptr %484, i32 0, i32 10
  %486 = getelementptr inbounds [32 x i16], ptr %485, i64 0, i64 0
  store i16 %483, ptr %486, align 8, !tbaa !23
  %487 = load ptr, ptr %20, align 8, !tbaa !5
  %488 = getelementptr inbounds %struct.page, ptr %487, i32 0, i32 4
  %489 = load i32, ptr %488, align 1, !tbaa !9
  %490 = load ptr, ptr %7, align 8, !tbaa !5
  %491 = getelementptr inbounds %struct.MDBX_cursor, ptr %490, i32 0, i32 6
  %492 = load ptr, ptr %491, align 8, !tbaa !32
  %493 = getelementptr inbounds %struct.tree, ptr %492, i32 0, i32 3
  store i32 %489, ptr %493, align 4, !tbaa !35
  %494 = load ptr, ptr %7, align 8, !tbaa !5
  %495 = getelementptr inbounds %struct.MDBX_cursor, ptr %494, i32 0, i32 6
  %496 = load ptr, ptr %495, align 8, !tbaa !32
  %497 = getelementptr inbounds %struct.tree, ptr %496, i32 0, i32 1
  %498 = load i16, ptr %497, align 2, !tbaa !33
  %499 = add i16 %498, -1
  store i16 %499, ptr %497, align 2, !tbaa !33
  store i32 14, ptr %23, align 4
  br label %528

500:                                              ; preds = %451
  %501 = load ptr, ptr %7, align 8, !tbaa !5
  %502 = getelementptr inbounds %struct.MDBX_cursor, ptr %501, i32 0, i32 1
  %503 = getelementptr inbounds %struct.anon.9, ptr %502, i32 0, i32 1
  store i8 1, ptr %503, align 1, !tbaa !19
  store i64 0, ptr %27, align 8, !tbaa !24
  %504 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %505 = zext i8 %504 to i32
  %506 = and i32 %505, 2
  %507 = icmp ne i32 %506, 0
  %508 = xor i1 %507, true
  %509 = xor i1 %508, true
  %510 = zext i1 %509 to i32
  %511 = sext i32 %510 to i64
  %512 = call i64 @llvm.expect.i64(i64 %511, i64 0)
  %513 = icmp ne i64 %512, 0
  br i1 %513, label %514, label %527

514:                                              ; preds = %500
  %515 = load ptr, ptr %7, align 8, !tbaa !5
  %516 = call i32 @cursor_validate_updating(ptr noundef %515)
  store i32 %516, ptr %13, align 4, !tbaa !9
  %517 = load i32, ptr %13, align 4, !tbaa !9
  %518 = icmp ne i32 %517, 0
  %519 = xor i1 %518, true
  %520 = xor i1 %519, true
  %521 = zext i1 %520 to i32
  %522 = sext i32 %521 to i64
  %523 = call i64 @llvm.expect.i64(i64 %522, i64 0)
  %524 = icmp ne i64 %523, 0
  br i1 %524, label %525, label %526

525:                                              ; preds = %514
  store i32 14, ptr %23, align 4
  br label %528

526:                                              ; preds = %514
  br label %527

527:                                              ; preds = %526, %500
  store i32 0, ptr %23, align 4
  br label %528

528:                                              ; preds = %527, %525, %472
  call void @llvm.lifetime.end.p0(i64 8, ptr %29) #10
  %529 = load i32, ptr %23, align 4
  switch i32 %529, label %4629 [
    i32 0, label %530
    i32 14, label %4523
  ]

530:                                              ; preds = %528
  br label %553

531:                                              ; preds = %311
  br label %532

532:                                              ; preds = %531
  %533 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 5), align 2, !tbaa !25
  %534 = zext i8 %533 to i32
  %535 = icmp sle i32 5, %534
  %536 = xor i1 %535, true
  %537 = xor i1 %536, true
  %538 = zext i1 %537 to i32
  %539 = sext i32 %538 to i64
  %540 = call i64 @llvm.expect.i64(i64 %539, i64 0)
  %541 = icmp ne i64 %540, 0
  br i1 %541, label %542, label %550

542:                                              ; preds = %532
  %543 = load ptr, ptr %7, align 8, !tbaa !5
  %544 = getelementptr inbounds %struct.MDBX_cursor, ptr %543, i32 0, i32 9
  %545 = load i64, ptr %27, align 8, !tbaa !24
  %546 = getelementptr inbounds [32 x ptr], ptr %544, i64 0, i64 %545
  %547 = load ptr, ptr %546, align 8, !tbaa !5
  %548 = getelementptr inbounds %struct.page, ptr %547, i32 0, i32 4
  %549 = load i32, ptr %548, align 1, !tbaa !9
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 5, ptr noundef @__func__.page_split, i32 noundef 1014, ptr noundef @.str.44, i32 noundef %549)
  br label %550

550:                                              ; preds = %542, %532
  br label %551

551:                                              ; preds = %550
  br label %552

552:                                              ; preds = %551
  br label %553

553:                                              ; preds = %552, %530
  %554 = load ptr, ptr %7, align 8, !tbaa !5
  %555 = call ptr @cursor_clone(ptr noundef %554, ptr noundef %30)
  store ptr %555, ptr %31, align 8, !tbaa !5
  %556 = load ptr, ptr %26, align 8, !tbaa !5
  %557 = load ptr, ptr %31, align 8, !tbaa !5
  %558 = getelementptr inbounds %struct.MDBX_cursor, ptr %557, i32 0, i32 9
  %559 = load ptr, ptr %31, align 8, !tbaa !5
  %560 = getelementptr inbounds %struct.MDBX_cursor, ptr %559, i32 0, i32 1
  %561 = getelementptr inbounds %struct.anon.9, ptr %560, i32 0, i32 1
  %562 = load i8, ptr %561, align 1, !tbaa !19
  %563 = sext i8 %562 to i64
  %564 = getelementptr inbounds [32 x ptr], ptr %558, i64 0, i64 %563
  store ptr %556, ptr %564, align 8, !tbaa !5
  %565 = load ptr, ptr %31, align 8, !tbaa !5
  %566 = getelementptr inbounds %struct.MDBX_cursor, ptr %565, i32 0, i32 10
  %567 = load ptr, ptr %31, align 8, !tbaa !5
  %568 = getelementptr inbounds %struct.MDBX_cursor, ptr %567, i32 0, i32 1
  %569 = getelementptr inbounds %struct.anon.9, ptr %568, i32 0, i32 1
  %570 = load i8, ptr %569, align 1, !tbaa !19
  %571 = sext i8 %570 to i64
  %572 = getelementptr inbounds [32 x i16], ptr %566, i64 0, i64 %571
  store i16 0, ptr %572, align 2, !tbaa !23
  %573 = load ptr, ptr %7, align 8, !tbaa !5
  %574 = getelementptr inbounds %struct.MDBX_cursor, ptr %573, i32 0, i32 10
  %575 = load i64, ptr %27, align 8, !tbaa !24
  %576 = getelementptr inbounds [32 x i16], ptr %574, i64 0, i64 %575
  %577 = load i16, ptr %576, align 2, !tbaa !23
  %578 = zext i16 %577 to i32
  %579 = add nsw i32 %578, 1
  %580 = trunc i32 %579 to i16
  %581 = load ptr, ptr %31, align 8, !tbaa !5
  %582 = getelementptr inbounds %struct.MDBX_cursor, ptr %581, i32 0, i32 10
  %583 = load i64, ptr %27, align 8, !tbaa !24
  %584 = getelementptr inbounds [32 x i16], ptr %582, i64 0, i64 %583
  store i16 %580, ptr %584, align 2, !tbaa !23
  %585 = load i64, ptr %21, align 8, !tbaa !24
  %586 = load i64, ptr %22, align 8, !tbaa !24
  %587 = icmp ult i64 %585, %586
  br i1 %587, label %588, label %592

588:                                              ; preds = %553
  %589 = load i64, ptr %22, align 8, !tbaa !24
  %590 = add i64 %589, 1
  %591 = lshr i64 %590, 1
  br label %597

592:                                              ; preds = %553
  %593 = load i64, ptr %22, align 8, !tbaa !24
  %594 = load i64, ptr %24, align 8, !tbaa !24
  %595 = sub i64 %593, %594
  %596 = add i64 %595, 1
  br label %597

597:                                              ; preds = %592, %588
  %598 = phi i64 [ %591, %588 ], [ %596, %592 ]
  store i64 %598, ptr %32, align 8, !tbaa !24
  br label %599

599:                                              ; preds = %597
  %600 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %601 = zext i8 %600 to i32
  %602 = and i32 %601, 1
  %603 = icmp ne i32 %602, 0
  %604 = xor i1 %603, true
  %605 = xor i1 %604, true
  %606 = zext i1 %605 to i32
  %607 = sext i32 %606 to i64
  %608 = call i64 @llvm.expect.i64(i64 %607, i64 1)
  %609 = icmp ne i64 %608, 0
  br i1 %609, label %610, label %636

610:                                              ; preds = %599
  br label %611

611:                                              ; preds = %610
  %612 = load i64, ptr %32, align 8, !tbaa !24
  %613 = load i64, ptr %24, align 8, !tbaa !24
  %614 = icmp uge i64 %612, %613
  br i1 %614, label %615, label %622

615:                                              ; preds = %611
  %616 = load i64, ptr %32, align 8, !tbaa !24
  %617 = load i64, ptr %22, align 8, !tbaa !24
  %618 = load i64, ptr %24, align 8, !tbaa !24
  %619 = sub i64 %617, %618
  %620 = add i64 %619, 1
  %621 = icmp ule i64 %616, %620
  br label %622

622:                                              ; preds = %615, %611
  %623 = phi i1 [ false, %611 ], [ %621, %615 ]
  %624 = xor i1 %623, true
  %625 = xor i1 %624, true
  %626 = xor i1 %625, true
  %627 = zext i1 %626 to i32
  %628 = sext i32 %627 to i64
  %629 = call i64 @llvm.expect.i64(i64 %628, i64 0)
  %630 = icmp ne i64 %629, 0
  br i1 %630, label %631, label %633

631:                                              ; preds = %622
  %632 = load ptr, ptr %15, align 8, !tbaa !5
  call void @mdbx_assert_fail(ptr noundef %632, ptr noundef @.str.45, ptr noundef @__func__.page_split, i32 noundef 1025) #11
  unreachable

633:                                              ; preds = %622
  br label %634

634:                                              ; preds = %633
  br label %635

635:                                              ; preds = %634
  br label %636

636:                                              ; preds = %635, %599
  br label %637

637:                                              ; preds = %636
  br label %638

638:                                              ; preds = %637
  br label %639

639:                                              ; preds = %638
  %640 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %641 = zext i8 %640 to i32
  %642 = and i32 %641, 1
  %643 = icmp ne i32 %642, 0
  %644 = xor i1 %643, true
  %645 = xor i1 %644, true
  %646 = zext i1 %645 to i32
  %647 = sext i32 %646 to i64
  %648 = call i64 @llvm.expect.i64(i64 %647, i64 1)
  %649 = icmp ne i64 %648, 0
  br i1 %649, label %650, label %675

650:                                              ; preds = %639
  br label %651

651:                                              ; preds = %650
  %652 = load ptr, ptr %20, align 8, !tbaa !5
  %653 = call zeroext i1 @is_branch(ptr noundef %652) #12
  br i1 %653, label %654, label %657

654:                                              ; preds = %651
  %655 = load i64, ptr %21, align 8, !tbaa !24
  %656 = icmp ugt i64 %655, 0
  br label %657

657:                                              ; preds = %654, %651
  %658 = phi i1 [ true, %651 ], [ %656, %654 ]
  %659 = xor i1 %658, true
  %660 = xor i1 %659, true
  %661 = xor i1 %660, true
  %662 = zext i1 %661 to i32
  %663 = sext i32 %662 to i64
  %664 = call i64 @llvm.expect.i64(i64 %663, i64 0)
  %665 = icmp ne i64 %664, 0
  br i1 %665, label %666, label %672

666:                                              ; preds = %657
  %667 = load ptr, ptr %7, align 8, !tbaa !5
  %668 = getelementptr inbounds %struct.MDBX_cursor, ptr %667, i32 0, i32 5
  %669 = load ptr, ptr %668, align 8, !tbaa !11
  %670 = getelementptr inbounds %struct.MDBX_txn, ptr %669, i32 0, i32 9
  %671 = load ptr, ptr %670, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %671, ptr noundef @.str.46, ptr noundef @__func__.page_split, i32 noundef 1027) #11
  unreachable

672:                                              ; preds = %657
  br label %673

673:                                              ; preds = %672
  br label %674

674:                                              ; preds = %673
  br label %675

675:                                              ; preds = %674, %639
  br label %676

676:                                              ; preds = %675
  br label %677

677:                                              ; preds = %676
  call void @llvm.memset.p0.i64(ptr align 8 %33, i8 0, i64 16, i1 false)
  %678 = load i64, ptr %21, align 8, !tbaa !24
  %679 = load i64, ptr %24, align 8, !tbaa !24
  %680 = icmp ult i64 %678, %679
  %681 = xor i1 %680, true
  %682 = xor i1 %681, true
  %683 = zext i1 %682 to i32
  %684 = sext i32 %683 to i64
  %685 = call i64 @llvm.expect.i64(i64 %684, i64 0)
  %686 = icmp ne i64 %685, 0
  br i1 %686, label %687, label %890

687:                                              ; preds = %677
  %688 = load i64, ptr %24, align 8, !tbaa !24
  store i64 %688, ptr %32, align 8, !tbaa !24
  %689 = load i64, ptr %21, align 8, !tbaa !24
  %690 = icmp eq i64 %689, 0
  br i1 %690, label %691, label %889

691:                                              ; preds = %687
  %692 = load i32, ptr %11, align 4, !tbaa !9
  %693 = and i32 %692, 262144
  %694 = icmp ne i32 %693, 0
  br i1 %694, label %889, label %695

695:                                              ; preds = %691
  store i64 0, ptr %32, align 8, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 8, ptr %34) #10
  store i64 0, ptr %34, align 8, !tbaa !24
  br label %696

696:                                              ; preds = %743, %695
  %697 = load i64, ptr %34, align 8, !tbaa !24
  %698 = load ptr, ptr %7, align 8, !tbaa !5
  %699 = getelementptr inbounds %struct.MDBX_cursor, ptr %698, i32 0, i32 1
  %700 = getelementptr inbounds %struct.anon.9, ptr %699, i32 0, i32 1
  %701 = load i8, ptr %700, align 1, !tbaa !19
  %702 = sext i8 %701 to i64
  %703 = icmp slt i64 %697, %702
  br i1 %703, label %705, label %704

704:                                              ; preds = %696
  store i32 31, ptr %23, align 4
  br label %746

705:                                              ; preds = %696
  %706 = load ptr, ptr %7, align 8, !tbaa !5
  %707 = getelementptr inbounds %struct.MDBX_cursor, ptr %706, i32 0, i32 10
  %708 = load i64, ptr %34, align 8, !tbaa !24
  %709 = getelementptr inbounds [32 x i16], ptr %707, i64 0, i64 %708
  %710 = load i16, ptr %709, align 2, !tbaa !23
  %711 = icmp ne i16 %710, 0
  br i1 %711, label %712, label %742

712:                                              ; preds = %705
  call void @llvm.lifetime.start.p0(i64 16, ptr %35) #10
  %713 = load ptr, ptr %7, align 8, !tbaa !5
  %714 = getelementptr inbounds %struct.MDBX_cursor, ptr %713, i32 0, i32 9
  %715 = load i64, ptr %34, align 8, !tbaa !24
  %716 = getelementptr inbounds [32 x ptr], ptr %714, i64 0, i64 %715
  %717 = load ptr, ptr %716, align 8, !tbaa !5
  %718 = load ptr, ptr %7, align 8, !tbaa !5
  %719 = getelementptr inbounds %struct.MDBX_cursor, ptr %718, i32 0, i32 10
  %720 = load i64, ptr %34, align 8, !tbaa !24
  %721 = getelementptr inbounds [32 x i16], ptr %719, i64 0, i64 %720
  %722 = load i16, ptr %721, align 2, !tbaa !23
  %723 = zext i16 %722 to i64
  %724 = call ptr @page_node(ptr noundef %717, i64 noundef %723) #12
  %725 = call { ptr, i64 } @get_key(ptr noundef %724) #12
  %726 = getelementptr inbounds { ptr, i64 }, ptr %35, i32 0, i32 0
  %727 = extractvalue { ptr, i64 } %725, 0
  store ptr %727, ptr %726, align 8
  %728 = getelementptr inbounds { ptr, i64 }, ptr %35, i32 0, i32 1
  %729 = extractvalue { ptr, i64 } %725, 1
  store i64 %729, ptr %728, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %33, ptr align 8 %35, i64 16, i1 false), !tbaa.struct !36
  call void @llvm.lifetime.end.p0(i64 16, ptr %35) #10
  %730 = load ptr, ptr %7, align 8, !tbaa !5
  %731 = getelementptr inbounds %struct.MDBX_cursor, ptr %730, i32 0, i32 7
  %732 = load ptr, ptr %731, align 8, !tbaa !37
  %733 = getelementptr inbounds %struct.clc2, ptr %732, i32 0, i32 0
  %734 = getelementptr inbounds %struct.clc, ptr %733, i32 0, i32 0
  %735 = load ptr, ptr %734, align 8, !tbaa !38
  %736 = load ptr, ptr %8, align 8, !tbaa !5
  %737 = call i32 %735(ptr noundef %736, ptr noundef %33)
  %738 = icmp sge i32 %737, 0
  br i1 %738, label %739, label %741

739:                                              ; preds = %712
  %740 = load i64, ptr %24, align 8, !tbaa !24
  store i64 %740, ptr %32, align 8, !tbaa !24
  br label %741

741:                                              ; preds = %739, %712
  store i32 31, ptr %23, align 4
  br label %746

742:                                              ; preds = %705
  br label %743

743:                                              ; preds = %742
  %744 = load i64, ptr %34, align 8, !tbaa !24
  %745 = add nsw i64 %744, 1
  store i64 %745, ptr %34, align 8, !tbaa !24
  br label %696, !llvm.loop !41

746:                                              ; preds = %741, %704
  call void @llvm.lifetime.end.p0(i64 8, ptr %34) #10
  br label %747

747:                                              ; preds = %746
  %748 = load i64, ptr %32, align 8, !tbaa !24
  %749 = icmp eq i64 %748, 0
  br i1 %749, label %750, label %828

750:                                              ; preds = %747
  %751 = load ptr, ptr %20, align 8, !tbaa !5
  %752 = call zeroext i1 @is_dupfix_leaf(ptr noundef %751) #12
  br i1 %752, label %753, label %766

753:                                              ; preds = %750
  call void @llvm.lifetime.start.p0(i64 16, ptr %36) #10
  %754 = load ptr, ptr %20, align 8, !tbaa !5
  %755 = load ptr, ptr %7, align 8, !tbaa !5
  %756 = getelementptr inbounds %struct.MDBX_cursor, ptr %755, i32 0, i32 6
  %757 = load ptr, ptr %756, align 8, !tbaa !32
  %758 = getelementptr inbounds %struct.tree, ptr %757, i32 0, i32 2
  %759 = load i32, ptr %758, align 4, !tbaa !43
  %760 = zext i32 %759 to i64
  %761 = call { ptr, i64 } @page_dupfix_key(ptr noundef %754, i64 noundef 0, i64 noundef %760) #12
  %762 = getelementptr inbounds { ptr, i64 }, ptr %36, i32 0, i32 0
  %763 = extractvalue { ptr, i64 } %761, 0
  store ptr %763, ptr %762, align 8
  %764 = getelementptr inbounds { ptr, i64 }, ptr %36, i32 0, i32 1
  %765 = extractvalue { ptr, i64 } %761, 1
  store i64 %765, ptr %764, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %33, ptr align 8 %36, i64 16, i1 false), !tbaa.struct !36
  call void @llvm.lifetime.end.p0(i64 16, ptr %36) #10
  br label %774

766:                                              ; preds = %750
  call void @llvm.lifetime.start.p0(i64 16, ptr %37) #10
  %767 = load ptr, ptr %20, align 8, !tbaa !5
  %768 = call ptr @page_node(ptr noundef %767, i64 noundef 0) #12
  %769 = call { ptr, i64 } @get_key(ptr noundef %768) #12
  %770 = getelementptr inbounds { ptr, i64 }, ptr %37, i32 0, i32 0
  %771 = extractvalue { ptr, i64 } %769, 0
  store ptr %771, ptr %770, align 8
  %772 = getelementptr inbounds { ptr, i64 }, ptr %37, i32 0, i32 1
  %773 = extractvalue { ptr, i64 } %769, 1
  store i64 %773, ptr %772, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %33, ptr align 8 %37, i64 16, i1 false), !tbaa.struct !36
  call void @llvm.lifetime.end.p0(i64 16, ptr %37) #10
  br label %774

774:                                              ; preds = %766, %753
  br label %775

775:                                              ; preds = %774
  %776 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %777 = zext i8 %776 to i32
  %778 = and i32 %777, 1
  %779 = icmp ne i32 %778, 0
  %780 = xor i1 %779, true
  %781 = xor i1 %780, true
  %782 = zext i1 %781 to i32
  %783 = sext i32 %782 to i64
  %784 = call i64 @llvm.expect.i64(i64 %783, i64 1)
  %785 = icmp ne i64 %784, 0
  br i1 %785, label %786, label %813

786:                                              ; preds = %775
  br label %787

787:                                              ; preds = %786
  %788 = load ptr, ptr %7, align 8, !tbaa !5
  %789 = getelementptr inbounds %struct.MDBX_cursor, ptr %788, i32 0, i32 7
  %790 = load ptr, ptr %789, align 8, !tbaa !37
  %791 = getelementptr inbounds %struct.clc2, ptr %790, i32 0, i32 0
  %792 = getelementptr inbounds %struct.clc, ptr %791, i32 0, i32 0
  %793 = load ptr, ptr %792, align 8, !tbaa !38
  %794 = load ptr, ptr %8, align 8, !tbaa !5
  %795 = call i32 %793(ptr noundef %794, ptr noundef %33)
  %796 = icmp slt i32 %795, 0
  %797 = xor i1 %796, true
  %798 = xor i1 %797, true
  %799 = xor i1 %798, true
  %800 = zext i1 %799 to i32
  %801 = sext i32 %800 to i64
  %802 = call i64 @llvm.expect.i64(i64 %801, i64 0)
  %803 = icmp ne i64 %802, 0
  br i1 %803, label %804, label %810

804:                                              ; preds = %787
  %805 = load ptr, ptr %7, align 8, !tbaa !5
  %806 = getelementptr inbounds %struct.MDBX_cursor, ptr %805, i32 0, i32 5
  %807 = load ptr, ptr %806, align 8, !tbaa !11
  %808 = getelementptr inbounds %struct.MDBX_txn, ptr %807, i32 0, i32 9
  %809 = load ptr, ptr %808, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %809, ptr noundef @.str.47, ptr noundef @__func__.page_split, i32 noundef 1050) #11
  unreachable

810:                                              ; preds = %787
  br label %811

811:                                              ; preds = %810
  br label %812

812:                                              ; preds = %811
  br label %813

813:                                              ; preds = %812, %775
  br label %814

814:                                              ; preds = %813
  br label %815

815:                                              ; preds = %814
  %816 = load ptr, ptr %7, align 8, !tbaa !5
  %817 = getelementptr inbounds %struct.MDBX_cursor, ptr %816, i32 0, i32 9
  %818 = load i64, ptr %27, align 8, !tbaa !24
  %819 = getelementptr inbounds [32 x ptr], ptr %817, i64 0, i64 %818
  %820 = load ptr, ptr %819, align 8, !tbaa !5
  %821 = call i64 @page_room(ptr noundef %820) #12
  %822 = load ptr, ptr %15, align 8, !tbaa !5
  %823 = call i64 @branch_size(ptr noundef %822, ptr noundef %33) #12
  %824 = icmp ult i64 %821, %823
  br i1 %824, label %825, label %827

825:                                              ; preds = %815
  %826 = load i64, ptr %24, align 8, !tbaa !24
  store i64 %826, ptr %32, align 8, !tbaa !24
  br label %827

827:                                              ; preds = %825, %815
  br label %828

828:                                              ; preds = %827, %747
  %829 = load i32, ptr %14, align 4, !tbaa !9
  %830 = icmp ne i32 %829, 0
  br i1 %830, label %831, label %888

831:                                              ; preds = %828
  br label %832

832:                                              ; preds = %831
  %833 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 5), align 2, !tbaa !25
  %834 = zext i8 %833 to i32
  %835 = icmp sle i32 6, %834
  %836 = xor i1 %835, true
  %837 = xor i1 %836, true
  %838 = zext i1 %837 to i32
  %839 = sext i32 %838 to i64
  %840 = call i64 @llvm.expect.i64(i64 %839, i64 0)
  %841 = icmp ne i64 %840, 0
  br i1 %841, label %842, label %862

842:                                              ; preds = %832
  %843 = load i32, ptr %14, align 4, !tbaa !9
  %844 = load ptr, ptr %7, align 8, !tbaa !5
  %845 = getelementptr inbounds %struct.MDBX_cursor, ptr %844, i32 0, i32 1
  %846 = getelementptr inbounds %struct.anon.9, ptr %845, i32 0, i32 1
  %847 = load i8, ptr %846, align 1, !tbaa !19
  %848 = sext i8 %847 to i32
  %849 = load i64, ptr %27, align 8, !tbaa !24
  %850 = load i64, ptr %32, align 8, !tbaa !24
  %851 = load i64, ptr %24, align 8, !tbaa !24
  %852 = getelementptr inbounds [510 x i8], ptr %19, i64 0, i64 0
  %853 = call ptr @mdbx_dump_val(ptr noundef %33, ptr noundef %852, i64 noundef 255)
  %854 = load ptr, ptr %7, align 8, !tbaa !5
  %855 = getelementptr inbounds %struct.MDBX_cursor, ptr %854, i32 0, i32 9
  %856 = load i64, ptr %27, align 8, !tbaa !24
  %857 = getelementptr inbounds [32 x ptr], ptr %855, i64 0, i64 %856
  %858 = load ptr, ptr %857, align 8, !tbaa !5
  %859 = call i64 @page_room(ptr noundef %858) #12
  %860 = load ptr, ptr %15, align 8, !tbaa !5
  %861 = call i64 @branch_size(ptr noundef %860, ptr noundef %33) #12
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef @__func__.page_split, i32 noundef 1059, ptr noundef @.str.48, i32 noundef %843, i32 noundef %848, i64 noundef %849, i64 noundef %850, i64 noundef %851, ptr noundef %853, i64 noundef %859, i64 noundef %861)
  br label %862

862:                                              ; preds = %842, %832
  br label %863

863:                                              ; preds = %862
  br label %864

864:                                              ; preds = %863
  br label %865

865:                                              ; preds = %864
  %866 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 5), align 2, !tbaa !25
  %867 = zext i8 %866 to i32
  %868 = icmp sle i32 6, %867
  %869 = xor i1 %868, true
  %870 = xor i1 %869, true
  %871 = zext i1 %870 to i32
  %872 = sext i32 %871 to i64
  %873 = call i64 @llvm.expect.i64(i64 %872, i64 0)
  %874 = icmp ne i64 %873, 0
  br i1 %874, label %875, label %885

875:                                              ; preds = %865
  %876 = load ptr, ptr %8, align 8, !tbaa !5
  %877 = getelementptr inbounds [510 x i8], ptr %19, i64 0, i64 0
  %878 = call ptr @mdbx_dump_val(ptr noundef %876, ptr noundef %877, i64 noundef 255)
  %879 = load ptr, ptr %9, align 8, !tbaa !5
  %880 = getelementptr inbounds [510 x i8], ptr %19, i64 0, i64 0
  %881 = getelementptr inbounds i8, ptr %880, i64 254
  %882 = getelementptr inbounds i8, ptr %881, i64 1
  %883 = call ptr @mdbx_dump_val(ptr noundef %879, ptr noundef %882, i64 noundef 255)
  %884 = load i64, ptr %21, align 8, !tbaa !24
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef @__func__.page_split, i32 noundef 1060, ptr noundef @.str.49, ptr noundef %878, ptr noundef %883, i64 noundef %884)
  br label %885

885:                                              ; preds = %875, %865
  br label %886

886:                                              ; preds = %885
  br label %887

887:                                              ; preds = %886
  br label %888

888:                                              ; preds = %887, %828
  br label %889

889:                                              ; preds = %888, %691, %687
  br label %890

890:                                              ; preds = %889, %677
  %891 = load i64, ptr %32, align 8, !tbaa !24
  %892 = load i64, ptr %22, align 8, !tbaa !24
  %893 = icmp eq i64 %891, %892
  %894 = zext i1 %893 to i8
  store i8 %894, ptr %38, align 1, !tbaa !44
  %895 = load i64, ptr %32, align 8, !tbaa !24
  %896 = icmp eq i64 %895, 0
  %897 = zext i1 %896 to i8
  store i8 %897, ptr %39, align 1, !tbaa !44
  %898 = load i8, ptr %38, align 1, !tbaa !44, !range !45, !noundef !46
  %899 = trunc i8 %898 to i1
  %900 = xor i1 %899, true
  %901 = xor i1 %900, true
  %902 = zext i1 %901 to i32
  %903 = sext i32 %902 to i64
  %904 = call i64 @llvm.expect.i64(i64 %903, i64 0)
  %905 = icmp ne i64 %904, 0
  br i1 %905, label %906, label %966

906:                                              ; preds = %890
  br label %907

907:                                              ; preds = %906
  %908 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 5), align 2, !tbaa !25
  %909 = zext i8 %908 to i32
  %910 = icmp sle i32 6, %909
  %911 = xor i1 %910, true
  %912 = xor i1 %911, true
  %913 = zext i1 %912 to i32
  %914 = sext i32 %913 to i64
  %915 = call i64 @llvm.expect.i64(i64 %914, i64 0)
  %916 = icmp ne i64 %915, 0
  br i1 %916, label %917, label %918

917:                                              ; preds = %907
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef @__func__.page_split, i32 noundef 1069, ptr noundef @.str.50, ptr noundef @.str.51)
  br label %918

918:                                              ; preds = %917, %907
  br label %919

919:                                              ; preds = %918
  br label %920

920:                                              ; preds = %919
  br label %921

921:                                              ; preds = %920
  %922 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %923 = zext i8 %922 to i32
  %924 = and i32 %923, 1
  %925 = icmp ne i32 %924, 0
  %926 = xor i1 %925, true
  %927 = xor i1 %926, true
  %928 = zext i1 %927 to i32
  %929 = sext i32 %928 to i64
  %930 = call i64 @llvm.expect.i64(i64 %929, i64 1)
  %931 = icmp ne i64 %930, 0
  br i1 %931, label %932, label %962

932:                                              ; preds = %921
  br label %933

933:                                              ; preds = %932
  %934 = load i64, ptr %21, align 8, !tbaa !24
  %935 = load i64, ptr %22, align 8, !tbaa !24
  %936 = icmp eq i64 %934, %935
  br i1 %936, label %937, label %944

937:                                              ; preds = %933
  %938 = load i64, ptr %32, align 8, !tbaa !24
  %939 = load i64, ptr %22, align 8, !tbaa !24
  %940 = icmp eq i64 %938, %939
  br i1 %940, label %941, label %944

941:                                              ; preds = %937
  %942 = load i64, ptr %24, align 8, !tbaa !24
  %943 = icmp eq i64 %942, 1
  br label %944

944:                                              ; preds = %941, %937, %933
  %945 = phi i1 [ false, %937 ], [ false, %933 ], [ %943, %941 ]
  %946 = xor i1 %945, true
  %947 = xor i1 %946, true
  %948 = xor i1 %947, true
  %949 = zext i1 %948 to i32
  %950 = sext i32 %949 to i64
  %951 = call i64 @llvm.expect.i64(i64 %950, i64 0)
  %952 = icmp ne i64 %951, 0
  br i1 %952, label %953, label %959

953:                                              ; preds = %944
  %954 = load ptr, ptr %7, align 8, !tbaa !5
  %955 = getelementptr inbounds %struct.MDBX_cursor, ptr %954, i32 0, i32 5
  %956 = load ptr, ptr %955, align 8, !tbaa !11
  %957 = getelementptr inbounds %struct.MDBX_txn, ptr %956, i32 0, i32 9
  %958 = load ptr, ptr %957, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %958, ptr noundef @.str.52, ptr noundef @__func__.page_split, i32 noundef 1070) #11
  unreachable

959:                                              ; preds = %944
  br label %960

960:                                              ; preds = %959
  br label %961

961:                                              ; preds = %960
  br label %962

962:                                              ; preds = %961, %921
  br label %963

963:                                              ; preds = %962
  br label %964

964:                                              ; preds = %963
  %965 = load ptr, ptr %8, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %33, ptr align 8 %965, i64 16, i1 false), !tbaa.struct !36
  br label %2232

966:                                              ; preds = %890
  %967 = load i8, ptr %39, align 1, !tbaa !44, !range !45, !noundef !46
  %968 = trunc i8 %967 to i1
  %969 = xor i1 %968, true
  %970 = xor i1 %969, true
  %971 = zext i1 %970 to i32
  %972 = sext i32 %971 to i64
  %973 = call i64 @llvm.expect.i64(i64 %972, i64 0)
  %974 = icmp ne i64 %973, 0
  br i1 %974, label %975, label %1048

975:                                              ; preds = %966
  br label %976

976:                                              ; preds = %975
  %977 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 5), align 2, !tbaa !25
  %978 = zext i8 %977 to i32
  %979 = icmp sle i32 6, %978
  %980 = xor i1 %979, true
  %981 = xor i1 %980, true
  %982 = zext i1 %981 to i32
  %983 = sext i32 %982 to i64
  %984 = call i64 @llvm.expect.i64(i64 %983, i64 0)
  %985 = icmp ne i64 %984, 0
  br i1 %985, label %986, label %987

986:                                              ; preds = %976
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef @__func__.page_split, i32 noundef 1074, ptr noundef @.str.53, ptr noundef @.str.54)
  br label %987

987:                                              ; preds = %986, %976
  br label %988

988:                                              ; preds = %987
  br label %989

989:                                              ; preds = %988
  br label %990

990:                                              ; preds = %989
  %991 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %992 = zext i8 %991 to i32
  %993 = and i32 %992, 1
  %994 = icmp ne i32 %993, 0
  %995 = xor i1 %994, true
  %996 = xor i1 %995, true
  %997 = zext i1 %996 to i32
  %998 = sext i32 %997 to i64
  %999 = call i64 @llvm.expect.i64(i64 %998, i64 1)
  %1000 = icmp ne i64 %999, 0
  br i1 %1000, label %1001, label %1029

1001:                                             ; preds = %990
  br label %1002

1002:                                             ; preds = %1001
  %1003 = load i64, ptr %21, align 8, !tbaa !24
  %1004 = icmp eq i64 %1003, 0
  br i1 %1004, label %1005, label %1011

1005:                                             ; preds = %1002
  %1006 = load i64, ptr %32, align 8, !tbaa !24
  %1007 = icmp eq i64 %1006, 0
  br i1 %1007, label %1008, label %1011

1008:                                             ; preds = %1005
  %1009 = load i64, ptr %24, align 8, !tbaa !24
  %1010 = icmp eq i64 %1009, 1
  br label %1011

1011:                                             ; preds = %1008, %1005, %1002
  %1012 = phi i1 [ false, %1005 ], [ false, %1002 ], [ %1010, %1008 ]
  %1013 = xor i1 %1012, true
  %1014 = xor i1 %1013, true
  %1015 = xor i1 %1014, true
  %1016 = zext i1 %1015 to i32
  %1017 = sext i32 %1016 to i64
  %1018 = call i64 @llvm.expect.i64(i64 %1017, i64 0)
  %1019 = icmp ne i64 %1018, 0
  br i1 %1019, label %1020, label %1026

1020:                                             ; preds = %1011
  %1021 = load ptr, ptr %7, align 8, !tbaa !5
  %1022 = getelementptr inbounds %struct.MDBX_cursor, ptr %1021, i32 0, i32 5
  %1023 = load ptr, ptr %1022, align 8, !tbaa !11
  %1024 = getelementptr inbounds %struct.MDBX_txn, ptr %1023, i32 0, i32 9
  %1025 = load ptr, ptr %1024, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %1025, ptr noundef @.str.55, ptr noundef @__func__.page_split, i32 noundef 1075) #11
  unreachable

1026:                                             ; preds = %1011
  br label %1027

1027:                                             ; preds = %1026
  br label %1028

1028:                                             ; preds = %1027
  br label %1029

1029:                                             ; preds = %1028, %990
  br label %1030

1030:                                             ; preds = %1029
  br label %1031

1031:                                             ; preds = %1030
  br label %1032

1032:                                             ; preds = %1031
  %1033 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 5), align 2, !tbaa !25
  %1034 = zext i8 %1033 to i32
  %1035 = icmp sle i32 6, %1034
  %1036 = xor i1 %1035, true
  %1037 = xor i1 %1036, true
  %1038 = zext i1 %1037 to i32
  %1039 = sext i32 %1038 to i64
  %1040 = call i64 @llvm.expect.i64(i64 %1039, i64 0)
  %1041 = icmp ne i64 %1040, 0
  br i1 %1041, label %1042, label %1045

1042:                                             ; preds = %1032
  %1043 = getelementptr inbounds [510 x i8], ptr %19, i64 0, i64 0
  %1044 = call ptr @mdbx_dump_val(ptr noundef %33, ptr noundef %1043, i64 noundef 255)
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef @__func__.page_split, i32 noundef 1076, ptr noundef @.str.56, ptr noundef %1044)
  br label %1045

1045:                                             ; preds = %1042, %1032
  br label %1046

1046:                                             ; preds = %1045
  br label %1047

1047:                                             ; preds = %1046
  br label %2231

1048:                                             ; preds = %966
  %1049 = load ptr, ptr %26, align 8, !tbaa !5
  %1050 = call zeroext i1 @is_dupfix_leaf(ptr noundef %1049) #12
  br i1 %1050, label %1051, label %1787

1051:                                             ; preds = %1048
  call void @llvm.lifetime.start.p0(i64 8, ptr %40) #10
  %1052 = load ptr, ptr %7, align 8, !tbaa !5
  %1053 = getelementptr inbounds %struct.MDBX_cursor, ptr %1052, i32 0, i32 10
  %1054 = load ptr, ptr %7, align 8, !tbaa !5
  %1055 = getelementptr inbounds %struct.MDBX_cursor, ptr %1054, i32 0, i32 1
  %1056 = getelementptr inbounds %struct.anon.9, ptr %1055, i32 0, i32 1
  %1057 = load i8, ptr %1056, align 1, !tbaa !19
  %1058 = sext i8 %1057 to i64
  %1059 = getelementptr inbounds [32 x i16], ptr %1053, i64 0, i64 %1058
  %1060 = load i16, ptr %1059, align 2, !tbaa !23
  %1061 = zext i16 %1060 to i64
  %1062 = load i64, ptr %32, align 8, !tbaa !24
  %1063 = sub i64 %1061, %1062
  store i64 %1063, ptr %40, align 8, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 8, ptr %41) #10
  %1064 = load ptr, ptr %7, align 8, !tbaa !5
  %1065 = getelementptr inbounds %struct.MDBX_cursor, ptr %1064, i32 0, i32 6
  %1066 = load ptr, ptr %1065, align 8, !tbaa !32
  %1067 = getelementptr inbounds %struct.tree, ptr %1066, i32 0, i32 2
  %1068 = load i32, ptr %1067, align 4, !tbaa !43
  %1069 = zext i32 %1068 to i64
  store i64 %1069, ptr %41, align 8, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 8, ptr %42) #10
  %1070 = load ptr, ptr %20, align 8, !tbaa !5
  %1071 = load i64, ptr %32, align 8, !tbaa !24
  %1072 = load i64, ptr %41, align 8, !tbaa !24
  %1073 = call ptr @page_dupfix_ptr(ptr noundef %1070, i64 noundef %1071, i64 noundef %1072) #12
  store ptr %1073, ptr %42, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %43) #10
  %1074 = load i64, ptr %22, align 8, !tbaa !24
  %1075 = load i64, ptr %32, align 8, !tbaa !24
  %1076 = sub i64 %1074, %1075
  %1077 = load i64, ptr %41, align 8, !tbaa !24
  %1078 = mul i64 %1076, %1077
  store i64 %1078, ptr %43, align 8, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 8, ptr %44) #10
  %1079 = load i64, ptr %22, align 8, !tbaa !24
  %1080 = load i64, ptr %32, align 8, !tbaa !24
  %1081 = sub i64 %1079, %1080
  %1082 = mul i64 %1081, 2
  store i64 %1082, ptr %44, align 8, !tbaa !24
  br label %1083

1083:                                             ; preds = %1051
  %1084 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %1085 = zext i8 %1084 to i32
  %1086 = and i32 %1085, 1
  %1087 = icmp ne i32 %1086, 0
  %1088 = xor i1 %1087, true
  %1089 = xor i1 %1088, true
  %1090 = zext i1 %1089 to i32
  %1091 = sext i32 %1090 to i64
  %1092 = call i64 @llvm.expect.i64(i64 %1091, i64 1)
  %1093 = icmp ne i64 %1092, 0
  br i1 %1093, label %1094, label %1119

1094:                                             ; preds = %1083
  br label %1095

1095:                                             ; preds = %1094
  %1096 = load ptr, ptr %20, align 8, !tbaa !5
  %1097 = getelementptr inbounds %struct.page, ptr %1096, i32 0, i32 3
  %1098 = getelementptr inbounds %struct.anon.19, ptr %1097, i32 0, i32 0
  %1099 = load i16, ptr %1098, align 1, !tbaa !19
  %1100 = zext i16 %1099 to i64
  %1101 = load i64, ptr %44, align 8, !tbaa !24
  %1102 = icmp uge i64 %1100, %1101
  %1103 = xor i1 %1102, true
  %1104 = xor i1 %1103, true
  %1105 = xor i1 %1104, true
  %1106 = zext i1 %1105 to i32
  %1107 = sext i32 %1106 to i64
  %1108 = call i64 @llvm.expect.i64(i64 %1107, i64 0)
  %1109 = icmp ne i64 %1108, 0
  br i1 %1109, label %1110, label %1116

1110:                                             ; preds = %1095
  %1111 = load ptr, ptr %7, align 8, !tbaa !5
  %1112 = getelementptr inbounds %struct.MDBX_cursor, ptr %1111, i32 0, i32 5
  %1113 = load ptr, ptr %1112, align 8, !tbaa !11
  %1114 = getelementptr inbounds %struct.MDBX_txn, ptr %1113, i32 0, i32 9
  %1115 = load ptr, ptr %1114, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %1115, ptr noundef @.str.57, ptr noundef @__func__.page_split, i32 noundef 1085) #11
  unreachable

1116:                                             ; preds = %1095
  br label %1117

1117:                                             ; preds = %1116
  br label %1118

1118:                                             ; preds = %1117
  br label %1119

1119:                                             ; preds = %1118, %1083
  br label %1120

1120:                                             ; preds = %1119
  br label %1121

1121:                                             ; preds = %1120
  %1122 = load i64, ptr %44, align 8, !tbaa !24
  %1123 = trunc i64 %1122 to i16
  %1124 = zext i16 %1123 to i32
  %1125 = load ptr, ptr %20, align 8, !tbaa !5
  %1126 = getelementptr inbounds %struct.page, ptr %1125, i32 0, i32 3
  %1127 = getelementptr inbounds %struct.anon.19, ptr %1126, i32 0, i32 0
  %1128 = load i16, ptr %1127, align 1, !tbaa !19
  %1129 = zext i16 %1128 to i32
  %1130 = sub nsw i32 %1129, %1124
  %1131 = trunc i32 %1130 to i16
  store i16 %1131, ptr %1127, align 1, !tbaa !19
  br label %1132

1132:                                             ; preds = %1121
  %1133 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %1134 = zext i8 %1133 to i32
  %1135 = and i32 %1134, 1
  %1136 = icmp ne i32 %1135, 0
  %1137 = xor i1 %1136, true
  %1138 = xor i1 %1137, true
  %1139 = zext i1 %1138 to i32
  %1140 = sext i32 %1139 to i64
  %1141 = call i64 @llvm.expect.i64(i64 %1140, i64 1)
  %1142 = icmp ne i64 %1141, 0
  br i1 %1142, label %1143, label %1169

1143:                                             ; preds = %1132
  br label %1144

1144:                                             ; preds = %1143
  %1145 = load ptr, ptr %26, align 8, !tbaa !5
  %1146 = getelementptr inbounds %struct.page, ptr %1145, i32 0, i32 3
  %1147 = getelementptr inbounds %struct.anon.19, ptr %1146, i32 0, i32 0
  %1148 = load i16, ptr %1147, align 1, !tbaa !19
  %1149 = zext i16 %1148 to i64
  %1150 = load i64, ptr %44, align 8, !tbaa !24
  %1151 = add i64 %1149, %1150
  %1152 = icmp ule i64 %1151, 65535
  %1153 = xor i1 %1152, true
  %1154 = xor i1 %1153, true
  %1155 = xor i1 %1154, true
  %1156 = zext i1 %1155 to i32
  %1157 = sext i32 %1156 to i64
  %1158 = call i64 @llvm.expect.i64(i64 %1157, i64 0)
  %1159 = icmp ne i64 %1158, 0
  br i1 %1159, label %1160, label %1166

1160:                                             ; preds = %1144
  %1161 = load ptr, ptr %7, align 8, !tbaa !5
  %1162 = getelementptr inbounds %struct.MDBX_cursor, ptr %1161, i32 0, i32 5
  %1163 = load ptr, ptr %1162, align 8, !tbaa !11
  %1164 = getelementptr inbounds %struct.MDBX_txn, ptr %1163, i32 0, i32 9
  %1165 = load ptr, ptr %1164, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %1165, ptr noundef @.str.58, ptr noundef @__func__.page_split, i32 noundef 1087) #11
  unreachable

1166:                                             ; preds = %1144
  br label %1167

1167:                                             ; preds = %1166
  br label %1168

1168:                                             ; preds = %1167
  br label %1169

1169:                                             ; preds = %1168, %1132
  br label %1170

1170:                                             ; preds = %1169
  br label %1171

1171:                                             ; preds = %1170
  %1172 = load i64, ptr %44, align 8, !tbaa !24
  %1173 = trunc i64 %1172 to i16
  %1174 = zext i16 %1173 to i32
  %1175 = load ptr, ptr %26, align 8, !tbaa !5
  %1176 = getelementptr inbounds %struct.page, ptr %1175, i32 0, i32 3
  %1177 = getelementptr inbounds %struct.anon.19, ptr %1176, i32 0, i32 0
  %1178 = load i16, ptr %1177, align 1, !tbaa !19
  %1179 = zext i16 %1178 to i32
  %1180 = add nsw i32 %1179, %1174
  %1181 = trunc i32 %1180 to i16
  store i16 %1181, ptr %1177, align 1, !tbaa !19
  br label %1182

1182:                                             ; preds = %1171
  %1183 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %1184 = zext i8 %1183 to i32
  %1185 = and i32 %1184, 1
  %1186 = icmp ne i32 %1185, 0
  %1187 = xor i1 %1186, true
  %1188 = xor i1 %1187, true
  %1189 = zext i1 %1188 to i32
  %1190 = sext i32 %1189 to i64
  %1191 = call i64 @llvm.expect.i64(i64 %1190, i64 1)
  %1192 = icmp ne i64 %1191, 0
  br i1 %1192, label %1193, label %1221

1193:                                             ; preds = %1182
  br label %1194

1194:                                             ; preds = %1193
  %1195 = load ptr, ptr %20, align 8, !tbaa !5
  %1196 = getelementptr inbounds %struct.page, ptr %1195, i32 0, i32 3
  %1197 = getelementptr inbounds %struct.anon.19, ptr %1196, i32 0, i32 1
  %1198 = load i16, ptr %1197, align 1, !tbaa !19
  %1199 = zext i16 %1198 to i64
  %1200 = load i64, ptr %43, align 8, !tbaa !24
  %1201 = add i64 %1199, %1200
  %1202 = load i64, ptr %44, align 8, !tbaa !24
  %1203 = sub i64 %1201, %1202
  %1204 = icmp ule i64 %1203, 65535
  %1205 = xor i1 %1204, true
  %1206 = xor i1 %1205, true
  %1207 = xor i1 %1206, true
  %1208 = zext i1 %1207 to i32
  %1209 = sext i32 %1208 to i64
  %1210 = call i64 @llvm.expect.i64(i64 %1209, i64 0)
  %1211 = icmp ne i64 %1210, 0
  br i1 %1211, label %1212, label %1218

1212:                                             ; preds = %1194
  %1213 = load ptr, ptr %7, align 8, !tbaa !5
  %1214 = getelementptr inbounds %struct.MDBX_cursor, ptr %1213, i32 0, i32 5
  %1215 = load ptr, ptr %1214, align 8, !tbaa !11
  %1216 = getelementptr inbounds %struct.MDBX_txn, ptr %1215, i32 0, i32 9
  %1217 = load ptr, ptr %1216, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %1217, ptr noundef @.str.59, ptr noundef @__func__.page_split, i32 noundef 1089) #11
  unreachable

1218:                                             ; preds = %1194
  br label %1219

1219:                                             ; preds = %1218
  br label %1220

1220:                                             ; preds = %1219
  br label %1221

1221:                                             ; preds = %1220, %1182
  br label %1222

1222:                                             ; preds = %1221
  br label %1223

1223:                                             ; preds = %1222
  %1224 = load i64, ptr %43, align 8, !tbaa !24
  %1225 = load i64, ptr %44, align 8, !tbaa !24
  %1226 = sub i64 %1224, %1225
  %1227 = trunc i64 %1226 to i16
  %1228 = zext i16 %1227 to i32
  %1229 = load ptr, ptr %20, align 8, !tbaa !5
  %1230 = getelementptr inbounds %struct.page, ptr %1229, i32 0, i32 3
  %1231 = getelementptr inbounds %struct.anon.19, ptr %1230, i32 0, i32 1
  %1232 = load i16, ptr %1231, align 1, !tbaa !19
  %1233 = zext i16 %1232 to i32
  %1234 = add nsw i32 %1233, %1228
  %1235 = trunc i32 %1234 to i16
  store i16 %1235, ptr %1231, align 1, !tbaa !19
  br label %1236

1236:                                             ; preds = %1223
  %1237 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %1238 = zext i8 %1237 to i32
  %1239 = and i32 %1238, 1
  %1240 = icmp ne i32 %1239, 0
  %1241 = xor i1 %1240, true
  %1242 = xor i1 %1241, true
  %1243 = zext i1 %1242 to i32
  %1244 = sext i32 %1243 to i64
  %1245 = call i64 @llvm.expect.i64(i64 %1244, i64 1)
  %1246 = icmp ne i64 %1245, 0
  br i1 %1246, label %1247, label %1274

1247:                                             ; preds = %1236
  br label %1248

1248:                                             ; preds = %1247
  %1249 = load ptr, ptr %26, align 8, !tbaa !5
  %1250 = getelementptr inbounds %struct.page, ptr %1249, i32 0, i32 3
  %1251 = getelementptr inbounds %struct.anon.19, ptr %1250, i32 0, i32 1
  %1252 = load i16, ptr %1251, align 1, !tbaa !19
  %1253 = zext i16 %1252 to i64
  %1254 = load i64, ptr %43, align 8, !tbaa !24
  %1255 = load i64, ptr %44, align 8, !tbaa !24
  %1256 = sub i64 %1254, %1255
  %1257 = icmp uge i64 %1253, %1256
  %1258 = xor i1 %1257, true
  %1259 = xor i1 %1258, true
  %1260 = xor i1 %1259, true
  %1261 = zext i1 %1260 to i32
  %1262 = sext i32 %1261 to i64
  %1263 = call i64 @llvm.expect.i64(i64 %1262, i64 0)
  %1264 = icmp ne i64 %1263, 0
  br i1 %1264, label %1265, label %1271

1265:                                             ; preds = %1248
  %1266 = load ptr, ptr %7, align 8, !tbaa !5
  %1267 = getelementptr inbounds %struct.MDBX_cursor, ptr %1266, i32 0, i32 5
  %1268 = load ptr, ptr %1267, align 8, !tbaa !11
  %1269 = getelementptr inbounds %struct.MDBX_txn, ptr %1268, i32 0, i32 9
  %1270 = load ptr, ptr %1269, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %1270, ptr noundef @.str.60, ptr noundef @__func__.page_split, i32 noundef 1091) #11
  unreachable

1271:                                             ; preds = %1248
  br label %1272

1272:                                             ; preds = %1271
  br label %1273

1273:                                             ; preds = %1272
  br label %1274

1274:                                             ; preds = %1273, %1236
  br label %1275

1275:                                             ; preds = %1274
  br label %1276

1276:                                             ; preds = %1275
  %1277 = load i64, ptr %43, align 8, !tbaa !24
  %1278 = load i64, ptr %44, align 8, !tbaa !24
  %1279 = sub i64 %1277, %1278
  %1280 = trunc i64 %1279 to i16
  %1281 = zext i16 %1280 to i32
  %1282 = load ptr, ptr %26, align 8, !tbaa !5
  %1283 = getelementptr inbounds %struct.page, ptr %1282, i32 0, i32 3
  %1284 = getelementptr inbounds %struct.anon.19, ptr %1283, i32 0, i32 1
  %1285 = load i16, ptr %1284, align 1, !tbaa !19
  %1286 = zext i16 %1285 to i32
  %1287 = sub nsw i32 %1286, %1281
  %1288 = trunc i32 %1287 to i16
  store i16 %1288, ptr %1284, align 1, !tbaa !19
  %1289 = load i64, ptr %41, align 8, !tbaa !24
  %1290 = getelementptr inbounds %struct.iovec, ptr %33, i32 0, i32 1
  store i64 %1289, ptr %1290, align 8, !tbaa !26
  %1291 = load i64, ptr %21, align 8, !tbaa !24
  %1292 = load i64, ptr %32, align 8, !tbaa !24
  %1293 = icmp ne i64 %1291, %1292
  br i1 %1293, label %1294, label %1296

1294:                                             ; preds = %1276
  %1295 = load ptr, ptr %42, align 8, !tbaa !5
  br label %1300

1296:                                             ; preds = %1276
  %1297 = load ptr, ptr %8, align 8, !tbaa !5
  %1298 = getelementptr inbounds %struct.iovec, ptr %1297, i32 0, i32 0
  %1299 = load ptr, ptr %1298, align 8, !tbaa !47
  br label %1300

1300:                                             ; preds = %1296, %1294
  %1301 = phi ptr [ %1295, %1294 ], [ %1299, %1296 ]
  %1302 = getelementptr inbounds %struct.iovec, ptr %33, i32 0, i32 0
  store ptr %1301, ptr %1302, align 8, !tbaa !47
  %1303 = load i64, ptr %40, align 8, !tbaa !24
  %1304 = icmp slt i64 %1303, 0
  br i1 %1304, label %1305, label %1528

1305:                                             ; preds = %1300
  br label %1306

1306:                                             ; preds = %1305
  %1307 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %1308 = zext i8 %1307 to i32
  %1309 = and i32 %1308, 1
  %1310 = icmp ne i32 %1309, 0
  %1311 = xor i1 %1310, true
  %1312 = xor i1 %1311, true
  %1313 = zext i1 %1312 to i32
  %1314 = sext i32 %1313 to i64
  %1315 = call i64 @llvm.expect.i64(i64 %1314, i64 1)
  %1316 = icmp ne i64 %1315, 0
  br i1 %1316, label %1317, label %1337

1317:                                             ; preds = %1306
  br label %1318

1318:                                             ; preds = %1317
  %1319 = load i64, ptr %41, align 8, !tbaa !24
  %1320 = icmp uge i64 %1319, 2
  %1321 = xor i1 %1320, true
  %1322 = xor i1 %1321, true
  %1323 = xor i1 %1322, true
  %1324 = zext i1 %1323 to i32
  %1325 = sext i32 %1324 to i64
  %1326 = call i64 @llvm.expect.i64(i64 %1325, i64 0)
  %1327 = icmp ne i64 %1326, 0
  br i1 %1327, label %1328, label %1334

1328:                                             ; preds = %1318
  %1329 = load ptr, ptr %7, align 8, !tbaa !5
  %1330 = getelementptr inbounds %struct.MDBX_cursor, ptr %1329, i32 0, i32 5
  %1331 = load ptr, ptr %1330, align 8, !tbaa !11
  %1332 = getelementptr inbounds %struct.MDBX_txn, ptr %1331, i32 0, i32 9
  %1333 = load ptr, ptr %1332, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %1333, ptr noundef @.str.61, ptr noundef @__func__.page_split, i32 noundef 1096) #11
  unreachable

1334:                                             ; preds = %1318
  br label %1335

1335:                                             ; preds = %1334
  br label %1336

1336:                                             ; preds = %1335
  br label %1337

1337:                                             ; preds = %1336, %1306
  br label %1338

1338:                                             ; preds = %1337
  br label %1339

1339:                                             ; preds = %1338
  call void @llvm.lifetime.start.p0(i64 8, ptr %45) #10
  %1340 = load ptr, ptr %20, align 8, !tbaa !5
  %1341 = load ptr, ptr %7, align 8, !tbaa !5
  %1342 = getelementptr inbounds %struct.MDBX_cursor, ptr %1341, i32 0, i32 10
  %1343 = load ptr, ptr %7, align 8, !tbaa !5
  %1344 = getelementptr inbounds %struct.MDBX_cursor, ptr %1343, i32 0, i32 1
  %1345 = getelementptr inbounds %struct.anon.9, ptr %1344, i32 0, i32 1
  %1346 = load i8, ptr %1345, align 1, !tbaa !19
  %1347 = sext i8 %1346 to i64
  %1348 = getelementptr inbounds [32 x i16], ptr %1342, i64 0, i64 %1347
  %1349 = load i16, ptr %1348, align 2, !tbaa !23
  %1350 = zext i16 %1349 to i64
  %1351 = load i64, ptr %41, align 8, !tbaa !24
  %1352 = call ptr @page_dupfix_ptr(ptr noundef %1340, i64 noundef %1350, i64 noundef %1351) #12
  store ptr %1352, ptr %45, align 8, !tbaa !5
  %1353 = load ptr, ptr %26, align 8, !tbaa !5
  %1354 = getelementptr inbounds %struct.page, ptr %1353, i32 0, i32 5
  %1355 = getelementptr inbounds [0 x i16], ptr %1354, i64 0, i64 0
  %1356 = load ptr, ptr %42, align 8, !tbaa !5
  %1357 = load i64, ptr %43, align 8, !tbaa !24
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %1355, ptr align 1 %1356, i64 %1357, i1 false)
  %1358 = load ptr, ptr %26, align 8, !tbaa !5
  %1359 = getelementptr inbounds %struct.page, ptr %1358, i32 0, i32 5
  %1360 = getelementptr inbounds [0 x i16], ptr %1359, i64 0, i64 0
  %1361 = getelementptr inbounds %struct.iovec, ptr %33, i32 0, i32 0
  store ptr %1360, ptr %1361, align 8, !tbaa !47
  %1362 = load ptr, ptr %45, align 8, !tbaa !5
  %1363 = ptrtoint ptr %1362 to i64
  %1364 = load i64, ptr %41, align 8, !tbaa !24
  %1365 = add nsw i64 %1363, %1364
  %1366 = inttoptr i64 %1365 to ptr
  %1367 = load ptr, ptr %45, align 8, !tbaa !5
  %1368 = load i64, ptr %32, align 8, !tbaa !24
  %1369 = load ptr, ptr %7, align 8, !tbaa !5
  %1370 = getelementptr inbounds %struct.MDBX_cursor, ptr %1369, i32 0, i32 10
  %1371 = load ptr, ptr %7, align 8, !tbaa !5
  %1372 = getelementptr inbounds %struct.MDBX_cursor, ptr %1371, i32 0, i32 1
  %1373 = getelementptr inbounds %struct.anon.9, ptr %1372, i32 0, i32 1
  %1374 = load i8, ptr %1373, align 1, !tbaa !19
  %1375 = sext i8 %1374 to i64
  %1376 = getelementptr inbounds [32 x i16], ptr %1370, i64 0, i64 %1375
  %1377 = load i16, ptr %1376, align 2, !tbaa !23
  %1378 = zext i16 %1377 to i64
  %1379 = sub i64 %1368, %1378
  %1380 = load i64, ptr %41, align 8, !tbaa !24
  %1381 = mul i64 %1379, %1380
  call void @llvm.memmove.p0.p0.i64(ptr align 1 %1366, ptr align 1 %1367, i64 %1381, i1 false)
  %1382 = load ptr, ptr %45, align 8, !tbaa !5
  %1383 = load ptr, ptr %8, align 8, !tbaa !5
  %1384 = getelementptr inbounds %struct.iovec, ptr %1383, i32 0, i32 0
  %1385 = load ptr, ptr %1384, align 8, !tbaa !47
  %1386 = load i64, ptr %41, align 8, !tbaa !24
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %1382, ptr align 1 %1385, i64 %1386, i1 false)
  br label %1387

1387:                                             ; preds = %1339
  %1388 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %1389 = zext i8 %1388 to i32
  %1390 = and i32 %1389, 1
  %1391 = icmp ne i32 %1390, 0
  %1392 = xor i1 %1391, true
  %1393 = xor i1 %1392, true
  %1394 = zext i1 %1393 to i32
  %1395 = sext i32 %1394 to i64
  %1396 = call i64 @llvm.expect.i64(i64 %1395, i64 1)
  %1397 = icmp ne i64 %1396, 0
  br i1 %1397, label %1398, label %1423

1398:                                             ; preds = %1387
  br label %1399

1399:                                             ; preds = %1398
  %1400 = load ptr, ptr %20, align 8, !tbaa !5
  %1401 = getelementptr inbounds %struct.page, ptr %1400, i32 0, i32 3
  %1402 = getelementptr inbounds %struct.anon.19, ptr %1401, i32 0, i32 0
  %1403 = load i16, ptr %1402, align 1, !tbaa !19
  %1404 = zext i16 %1403 to i32
  %1405 = sub nsw i32 65535, %1404
  %1406 = icmp sge i32 %1405, 2
  %1407 = xor i1 %1406, true
  %1408 = xor i1 %1407, true
  %1409 = xor i1 %1408, true
  %1410 = zext i1 %1409 to i32
  %1411 = sext i32 %1410 to i64
  %1412 = call i64 @llvm.expect.i64(i64 %1411, i64 0)
  %1413 = icmp ne i64 %1412, 0
  br i1 %1413, label %1414, label %1420

1414:                                             ; preds = %1399
  %1415 = load ptr, ptr %7, align 8, !tbaa !5
  %1416 = getelementptr inbounds %struct.MDBX_cursor, ptr %1415, i32 0, i32 5
  %1417 = load ptr, ptr %1416, align 8, !tbaa !11
  %1418 = getelementptr inbounds %struct.MDBX_txn, ptr %1417, i32 0, i32 9
  %1419 = load ptr, ptr %1418, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %1419, ptr noundef @.str.62, ptr noundef @__func__.page_split, i32 noundef 1102) #11
  unreachable

1420:                                             ; preds = %1399
  br label %1421

1421:                                             ; preds = %1420
  br label %1422

1422:                                             ; preds = %1421
  br label %1423

1423:                                             ; preds = %1422, %1387
  br label %1424

1424:                                             ; preds = %1423
  br label %1425

1425:                                             ; preds = %1424
  %1426 = load ptr, ptr %20, align 8, !tbaa !5
  %1427 = getelementptr inbounds %struct.page, ptr %1426, i32 0, i32 3
  %1428 = getelementptr inbounds %struct.anon.19, ptr %1427, i32 0, i32 0
  %1429 = load i16, ptr %1428, align 1, !tbaa !19
  %1430 = zext i16 %1429 to i64
  %1431 = add i64 %1430, 2
  %1432 = trunc i64 %1431 to i16
  store i16 %1432, ptr %1428, align 1, !tbaa !19
  br label %1433

1433:                                             ; preds = %1425
  %1434 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %1435 = zext i8 %1434 to i32
  %1436 = and i32 %1435, 1
  %1437 = icmp ne i32 %1436, 0
  %1438 = xor i1 %1437, true
  %1439 = xor i1 %1438, true
  %1440 = zext i1 %1439 to i32
  %1441 = sext i32 %1440 to i64
  %1442 = call i64 @llvm.expect.i64(i64 %1441, i64 1)
  %1443 = icmp ne i64 %1442, 0
  br i1 %1443, label %1444, label %1470

1444:                                             ; preds = %1433
  br label %1445

1445:                                             ; preds = %1444
  %1446 = load ptr, ptr %20, align 8, !tbaa !5
  %1447 = getelementptr inbounds %struct.page, ptr %1446, i32 0, i32 3
  %1448 = getelementptr inbounds %struct.anon.19, ptr %1447, i32 0, i32 1
  %1449 = load i16, ptr %1448, align 1, !tbaa !19
  %1450 = zext i16 %1449 to i64
  %1451 = load i64, ptr %41, align 8, !tbaa !24
  %1452 = sub i64 %1451, 2
  %1453 = icmp uge i64 %1450, %1452
  %1454 = xor i1 %1453, true
  %1455 = xor i1 %1454, true
  %1456 = xor i1 %1455, true
  %1457 = zext i1 %1456 to i32
  %1458 = sext i32 %1457 to i64
  %1459 = call i64 @llvm.expect.i64(i64 %1458, i64 0)
  %1460 = icmp ne i64 %1459, 0
  br i1 %1460, label %1461, label %1467

1461:                                             ; preds = %1445
  %1462 = load ptr, ptr %7, align 8, !tbaa !5
  %1463 = getelementptr inbounds %struct.MDBX_cursor, ptr %1462, i32 0, i32 5
  %1464 = load ptr, ptr %1463, align 8, !tbaa !11
  %1465 = getelementptr inbounds %struct.MDBX_txn, ptr %1464, i32 0, i32 9
  %1466 = load ptr, ptr %1465, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %1466, ptr noundef @.str.63, ptr noundef @__func__.page_split, i32 noundef 1104) #11
  unreachable

1467:                                             ; preds = %1445
  br label %1468

1468:                                             ; preds = %1467
  br label %1469

1469:                                             ; preds = %1468
  br label %1470

1470:                                             ; preds = %1469, %1433
  br label %1471

1471:                                             ; preds = %1470
  br label %1472

1472:                                             ; preds = %1471
  %1473 = load i64, ptr %41, align 8, !tbaa !24
  %1474 = sub i64 %1473, 2
  %1475 = trunc i64 %1474 to i16
  %1476 = zext i16 %1475 to i32
  %1477 = load ptr, ptr %20, align 8, !tbaa !5
  %1478 = getelementptr inbounds %struct.page, ptr %1477, i32 0, i32 3
  %1479 = getelementptr inbounds %struct.anon.19, ptr %1478, i32 0, i32 1
  %1480 = load i16, ptr %1479, align 1, !tbaa !19
  %1481 = zext i16 %1480 to i32
  %1482 = sub nsw i32 %1481, %1476
  %1483 = trunc i32 %1482 to i16
  store i16 %1483, ptr %1479, align 1, !tbaa !19
  br label %1484

1484:                                             ; preds = %1472
  %1485 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %1486 = zext i8 %1485 to i32
  %1487 = and i32 %1486, 1
  %1488 = icmp ne i32 %1487, 0
  %1489 = xor i1 %1488, true
  %1490 = xor i1 %1489, true
  %1491 = zext i1 %1490 to i32
  %1492 = sext i32 %1491 to i64
  %1493 = call i64 @llvm.expect.i64(i64 %1492, i64 1)
  %1494 = icmp ne i64 %1493, 0
  br i1 %1494, label %1495, label %1525

1495:                                             ; preds = %1484
  br label %1496

1496:                                             ; preds = %1495
  %1497 = load i64, ptr %41, align 8, !tbaa !24
  %1498 = load ptr, ptr %20, align 8, !tbaa !5
  %1499 = call i64 @page_numkeys(ptr noundef %1498) #12
  %1500 = and i64 %1497, %1499
  %1501 = load ptr, ptr %20, align 8, !tbaa !5
  %1502 = getelementptr inbounds %struct.page, ptr %1501, i32 0, i32 3
  %1503 = getelementptr inbounds %struct.anon.19, ptr %1502, i32 0, i32 1
  %1504 = load i16, ptr %1503, align 1, !tbaa !19
  %1505 = zext i16 %1504 to i64
  %1506 = xor i64 %1500, %1505
  %1507 = and i64 %1506, 1
  %1508 = icmp eq i64 %1507, 0
  %1509 = xor i1 %1508, true
  %1510 = xor i1 %1509, true
  %1511 = xor i1 %1510, true
  %1512 = zext i1 %1511 to i32
  %1513 = sext i32 %1512 to i64
  %1514 = call i64 @llvm.expect.i64(i64 %1513, i64 0)
  %1515 = icmp ne i64 %1514, 0
  br i1 %1515, label %1516, label %1522

1516:                                             ; preds = %1496
  %1517 = load ptr, ptr %7, align 8, !tbaa !5
  %1518 = getelementptr inbounds %struct.MDBX_cursor, ptr %1517, i32 0, i32 5
  %1519 = load ptr, ptr %1518, align 8, !tbaa !11
  %1520 = getelementptr inbounds %struct.MDBX_txn, ptr %1519, i32 0, i32 9
  %1521 = load ptr, ptr %1520, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %1521, ptr noundef @.str.64, ptr noundef @__func__.page_split, i32 noundef 1106) #11
  unreachable

1522:                                             ; preds = %1496
  br label %1523

1523:                                             ; preds = %1522
  br label %1524

1524:                                             ; preds = %1523
  br label %1525

1525:                                             ; preds = %1524, %1484
  br label %1526

1526:                                             ; preds = %1525
  br label %1527

1527:                                             ; preds = %1526
  call void @llvm.lifetime.end.p0(i64 8, ptr %45) #10
  br label %1747

1528:                                             ; preds = %1300
  %1529 = load ptr, ptr %26, align 8, !tbaa !5
  %1530 = getelementptr inbounds %struct.page, ptr %1529, i32 0, i32 5
  %1531 = getelementptr inbounds [0 x i16], ptr %1530, i64 0, i64 0
  %1532 = load ptr, ptr %42, align 8, !tbaa !5
  %1533 = load i64, ptr %40, align 8, !tbaa !24
  %1534 = load i64, ptr %41, align 8, !tbaa !24
  %1535 = mul i64 %1533, %1534
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %1531, ptr align 1 %1532, i64 %1535, i1 false)
  call void @llvm.lifetime.start.p0(i64 8, ptr %46) #10
  %1536 = load ptr, ptr %26, align 8, !tbaa !5
  %1537 = load i64, ptr %40, align 8, !tbaa !24
  %1538 = load i64, ptr %41, align 8, !tbaa !24
  %1539 = call ptr @page_dupfix_ptr(ptr noundef %1536, i64 noundef %1537, i64 noundef %1538) #12
  store ptr %1539, ptr %46, align 8, !tbaa !5
  %1540 = load ptr, ptr %46, align 8, !tbaa !5
  %1541 = load ptr, ptr %8, align 8, !tbaa !5
  %1542 = getelementptr inbounds %struct.iovec, ptr %1541, i32 0, i32 0
  %1543 = load ptr, ptr %1542, align 8, !tbaa !47
  %1544 = load i64, ptr %41, align 8, !tbaa !24
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %1540, ptr align 1 %1543, i64 %1544, i1 false)
  %1545 = load ptr, ptr %46, align 8, !tbaa !5
  %1546 = ptrtoint ptr %1545 to i64
  %1547 = load i64, ptr %41, align 8, !tbaa !24
  %1548 = add nsw i64 %1546, %1547
  %1549 = inttoptr i64 %1548 to ptr
  %1550 = load ptr, ptr %42, align 8, !tbaa !5
  %1551 = ptrtoint ptr %1550 to i64
  %1552 = load i64, ptr %40, align 8, !tbaa !24
  %1553 = load i64, ptr %41, align 8, !tbaa !24
  %1554 = mul i64 %1552, %1553
  %1555 = add nsw i64 %1551, %1554
  %1556 = inttoptr i64 %1555 to ptr
  %1557 = load i64, ptr %43, align 8, !tbaa !24
  %1558 = load i64, ptr %40, align 8, !tbaa !24
  %1559 = load i64, ptr %41, align 8, !tbaa !24
  %1560 = mul i64 %1558, %1559
  %1561 = sub i64 %1557, %1560
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %1549, ptr align 1 %1556, i64 %1561, i1 false)
  br label %1562

1562:                                             ; preds = %1528
  %1563 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %1564 = zext i8 %1563 to i32
  %1565 = and i32 %1564, 1
  %1566 = icmp ne i32 %1565, 0
  %1567 = xor i1 %1566, true
  %1568 = xor i1 %1567, true
  %1569 = zext i1 %1568 to i32
  %1570 = sext i32 %1569 to i64
  %1571 = call i64 @llvm.expect.i64(i64 %1570, i64 1)
  %1572 = icmp ne i64 %1571, 0
  br i1 %1572, label %1573, label %1598

1573:                                             ; preds = %1562
  br label %1574

1574:                                             ; preds = %1573
  %1575 = load ptr, ptr %26, align 8, !tbaa !5
  %1576 = getelementptr inbounds %struct.page, ptr %1575, i32 0, i32 3
  %1577 = getelementptr inbounds %struct.anon.19, ptr %1576, i32 0, i32 0
  %1578 = load i16, ptr %1577, align 1, !tbaa !19
  %1579 = zext i16 %1578 to i32
  %1580 = sub nsw i32 65535, %1579
  %1581 = icmp sge i32 %1580, 2
  %1582 = xor i1 %1581, true
  %1583 = xor i1 %1582, true
  %1584 = xor i1 %1583, true
  %1585 = zext i1 %1584 to i32
  %1586 = sext i32 %1585 to i64
  %1587 = call i64 @llvm.expect.i64(i64 %1586, i64 0)
  %1588 = icmp ne i64 %1587, 0
  br i1 %1588, label %1589, label %1595

1589:                                             ; preds = %1574
  %1590 = load ptr, ptr %7, align 8, !tbaa !5
  %1591 = getelementptr inbounds %struct.MDBX_cursor, ptr %1590, i32 0, i32 5
  %1592 = load ptr, ptr %1591, align 8, !tbaa !11
  %1593 = getelementptr inbounds %struct.MDBX_txn, ptr %1592, i32 0, i32 9
  %1594 = load ptr, ptr %1593, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %1594, ptr noundef @.str.65, ptr noundef @__func__.page_split, i32 noundef 1112) #11
  unreachable

1595:                                             ; preds = %1574
  br label %1596

1596:                                             ; preds = %1595
  br label %1597

1597:                                             ; preds = %1596
  br label %1598

1598:                                             ; preds = %1597, %1562
  br label %1599

1599:                                             ; preds = %1598
  br label %1600

1600:                                             ; preds = %1599
  %1601 = load ptr, ptr %26, align 8, !tbaa !5
  %1602 = getelementptr inbounds %struct.page, ptr %1601, i32 0, i32 3
  %1603 = getelementptr inbounds %struct.anon.19, ptr %1602, i32 0, i32 0
  %1604 = load i16, ptr %1603, align 1, !tbaa !19
  %1605 = zext i16 %1604 to i64
  %1606 = add i64 %1605, 2
  %1607 = trunc i64 %1606 to i16
  store i16 %1607, ptr %1603, align 1, !tbaa !19
  br label %1608

1608:                                             ; preds = %1600
  %1609 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %1610 = zext i8 %1609 to i32
  %1611 = and i32 %1610, 1
  %1612 = icmp ne i32 %1611, 0
  %1613 = xor i1 %1612, true
  %1614 = xor i1 %1613, true
  %1615 = zext i1 %1614 to i32
  %1616 = sext i32 %1615 to i64
  %1617 = call i64 @llvm.expect.i64(i64 %1616, i64 1)
  %1618 = icmp ne i64 %1617, 0
  br i1 %1618, label %1619, label %1645

1619:                                             ; preds = %1608
  br label %1620

1620:                                             ; preds = %1619
  %1621 = load ptr, ptr %26, align 8, !tbaa !5
  %1622 = getelementptr inbounds %struct.page, ptr %1621, i32 0, i32 3
  %1623 = getelementptr inbounds %struct.anon.19, ptr %1622, i32 0, i32 1
  %1624 = load i16, ptr %1623, align 1, !tbaa !19
  %1625 = zext i16 %1624 to i64
  %1626 = load i64, ptr %41, align 8, !tbaa !24
  %1627 = sub i64 %1626, 2
  %1628 = icmp uge i64 %1625, %1627
  %1629 = xor i1 %1628, true
  %1630 = xor i1 %1629, true
  %1631 = xor i1 %1630, true
  %1632 = zext i1 %1631 to i32
  %1633 = sext i32 %1632 to i64
  %1634 = call i64 @llvm.expect.i64(i64 %1633, i64 0)
  %1635 = icmp ne i64 %1634, 0
  br i1 %1635, label %1636, label %1642

1636:                                             ; preds = %1620
  %1637 = load ptr, ptr %7, align 8, !tbaa !5
  %1638 = getelementptr inbounds %struct.MDBX_cursor, ptr %1637, i32 0, i32 5
  %1639 = load ptr, ptr %1638, align 8, !tbaa !11
  %1640 = getelementptr inbounds %struct.MDBX_txn, ptr %1639, i32 0, i32 9
  %1641 = load ptr, ptr %1640, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %1641, ptr noundef @.str.66, ptr noundef @__func__.page_split, i32 noundef 1114) #11
  unreachable

1642:                                             ; preds = %1620
  br label %1643

1643:                                             ; preds = %1642
  br label %1644

1644:                                             ; preds = %1643
  br label %1645

1645:                                             ; preds = %1644, %1608
  br label %1646

1646:                                             ; preds = %1645
  br label %1647

1647:                                             ; preds = %1646
  %1648 = load i64, ptr %41, align 8, !tbaa !24
  %1649 = sub i64 %1648, 2
  %1650 = trunc i64 %1649 to i16
  %1651 = zext i16 %1650 to i32
  %1652 = load ptr, ptr %26, align 8, !tbaa !5
  %1653 = getelementptr inbounds %struct.page, ptr %1652, i32 0, i32 3
  %1654 = getelementptr inbounds %struct.anon.19, ptr %1653, i32 0, i32 1
  %1655 = load i16, ptr %1654, align 1, !tbaa !19
  %1656 = zext i16 %1655 to i32
  %1657 = sub nsw i32 %1656, %1651
  %1658 = trunc i32 %1657 to i16
  store i16 %1658, ptr %1654, align 1, !tbaa !19
  br label %1659

1659:                                             ; preds = %1647
  %1660 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %1661 = zext i8 %1660 to i32
  %1662 = and i32 %1661, 1
  %1663 = icmp ne i32 %1662, 0
  %1664 = xor i1 %1663, true
  %1665 = xor i1 %1664, true
  %1666 = zext i1 %1665 to i32
  %1667 = sext i32 %1666 to i64
  %1668 = call i64 @llvm.expect.i64(i64 %1667, i64 1)
  %1669 = icmp ne i64 %1668, 0
  br i1 %1669, label %1670, label %1690

1670:                                             ; preds = %1659
  br label %1671

1671:                                             ; preds = %1670
  %1672 = load i64, ptr %40, align 8, !tbaa !24
  %1673 = icmp sle i64 %1672, 65535
  %1674 = xor i1 %1673, true
  %1675 = xor i1 %1674, true
  %1676 = xor i1 %1675, true
  %1677 = zext i1 %1676 to i32
  %1678 = sext i32 %1677 to i64
  %1679 = call i64 @llvm.expect.i64(i64 %1678, i64 0)
  %1680 = icmp ne i64 %1679, 0
  br i1 %1680, label %1681, label %1687

1681:                                             ; preds = %1671
  %1682 = load ptr, ptr %7, align 8, !tbaa !5
  %1683 = getelementptr inbounds %struct.MDBX_cursor, ptr %1682, i32 0, i32 5
  %1684 = load ptr, ptr %1683, align 8, !tbaa !11
  %1685 = getelementptr inbounds %struct.MDBX_txn, ptr %1684, i32 0, i32 9
  %1686 = load ptr, ptr %1685, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %1686, ptr noundef @.str.67, ptr noundef @__func__.page_split, i32 noundef 1116) #11
  unreachable

1687:                                             ; preds = %1671
  br label %1688

1688:                                             ; preds = %1687
  br label %1689

1689:                                             ; preds = %1688
  br label %1690

1690:                                             ; preds = %1689, %1659
  br label %1691

1691:                                             ; preds = %1690
  br label %1692

1692:                                             ; preds = %1691
  %1693 = load i64, ptr %40, align 8, !tbaa !24
  %1694 = trunc i64 %1693 to i16
  %1695 = load ptr, ptr %7, align 8, !tbaa !5
  %1696 = getelementptr inbounds %struct.MDBX_cursor, ptr %1695, i32 0, i32 10
  %1697 = load ptr, ptr %7, align 8, !tbaa !5
  %1698 = getelementptr inbounds %struct.MDBX_cursor, ptr %1697, i32 0, i32 1
  %1699 = getelementptr inbounds %struct.anon.9, ptr %1698, i32 0, i32 1
  %1700 = load i8, ptr %1699, align 1, !tbaa !19
  %1701 = sext i8 %1700 to i64
  %1702 = getelementptr inbounds [32 x i16], ptr %1696, i64 0, i64 %1701
  store i16 %1694, ptr %1702, align 2, !tbaa !23
  br label %1703

1703:                                             ; preds = %1692
  %1704 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %1705 = zext i8 %1704 to i32
  %1706 = and i32 %1705, 1
  %1707 = icmp ne i32 %1706, 0
  %1708 = xor i1 %1707, true
  %1709 = xor i1 %1708, true
  %1710 = zext i1 %1709 to i32
  %1711 = sext i32 %1710 to i64
  %1712 = call i64 @llvm.expect.i64(i64 %1711, i64 1)
  %1713 = icmp ne i64 %1712, 0
  br i1 %1713, label %1714, label %1744

1714:                                             ; preds = %1703
  br label %1715

1715:                                             ; preds = %1714
  %1716 = load i64, ptr %41, align 8, !tbaa !24
  %1717 = load ptr, ptr %26, align 8, !tbaa !5
  %1718 = call i64 @page_numkeys(ptr noundef %1717) #12
  %1719 = and i64 %1716, %1718
  %1720 = load ptr, ptr %26, align 8, !tbaa !5
  %1721 = getelementptr inbounds %struct.page, ptr %1720, i32 0, i32 3
  %1722 = getelementptr inbounds %struct.anon.19, ptr %1721, i32 0, i32 1
  %1723 = load i16, ptr %1722, align 1, !tbaa !19
  %1724 = zext i16 %1723 to i64
  %1725 = xor i64 %1719, %1724
  %1726 = and i64 %1725, 1
  %1727 = icmp eq i64 %1726, 0
  %1728 = xor i1 %1727, true
  %1729 = xor i1 %1728, true
  %1730 = xor i1 %1729, true
  %1731 = zext i1 %1730 to i32
  %1732 = sext i32 %1731 to i64
  %1733 = call i64 @llvm.expect.i64(i64 %1732, i64 0)
  %1734 = icmp ne i64 %1733, 0
  br i1 %1734, label %1735, label %1741

1735:                                             ; preds = %1715
  %1736 = load ptr, ptr %7, align 8, !tbaa !5
  %1737 = getelementptr inbounds %struct.MDBX_cursor, ptr %1736, i32 0, i32 5
  %1738 = load ptr, ptr %1737, align 8, !tbaa !11
  %1739 = getelementptr inbounds %struct.MDBX_txn, ptr %1738, i32 0, i32 9
  %1740 = load ptr, ptr %1739, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %1740, ptr noundef @.str.68, ptr noundef @__func__.page_split, i32 noundef 1118) #11
  unreachable

1741:                                             ; preds = %1715
  br label %1742

1742:                                             ; preds = %1741
  br label %1743

1743:                                             ; preds = %1742
  br label %1744

1744:                                             ; preds = %1743, %1703
  br label %1745

1745:                                             ; preds = %1744
  br label %1746

1746:                                             ; preds = %1745
  call void @llvm.lifetime.end.p0(i64 8, ptr %46) #10
  br label %1747

1747:                                             ; preds = %1746, %1527
  %1748 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %1749 = zext i8 %1748 to i32
  %1750 = and i32 %1749, 2
  %1751 = icmp ne i32 %1750, 0
  %1752 = xor i1 %1751, true
  %1753 = xor i1 %1752, true
  %1754 = zext i1 %1753 to i32
  %1755 = sext i32 %1754 to i64
  %1756 = call i64 @llvm.expect.i64(i64 %1755, i64 0)
  %1757 = icmp ne i64 %1756, 0
  br i1 %1757, label %1758, label %1783

1758:                                             ; preds = %1747
  %1759 = load ptr, ptr %7, align 8, !tbaa !5
  %1760 = call i32 @cursor_validate_updating(ptr noundef %1759)
  store i32 %1760, ptr %13, align 4, !tbaa !9
  %1761 = load i32, ptr %13, align 4, !tbaa !9
  %1762 = icmp ne i32 %1761, 0
  %1763 = xor i1 %1762, true
  %1764 = xor i1 %1763, true
  %1765 = zext i1 %1764 to i32
  %1766 = sext i32 %1765 to i64
  %1767 = call i64 @llvm.expect.i64(i64 %1766, i64 0)
  %1768 = icmp ne i64 %1767, 0
  br i1 %1768, label %1769, label %1770

1769:                                             ; preds = %1758
  store i32 14, ptr %23, align 4
  br label %1784

1770:                                             ; preds = %1758
  %1771 = load ptr, ptr %31, align 8, !tbaa !5
  %1772 = call i32 @cursor_validate_updating(ptr noundef %1771)
  store i32 %1772, ptr %13, align 4, !tbaa !9
  %1773 = load i32, ptr %13, align 4, !tbaa !9
  %1774 = icmp ne i32 %1773, 0
  %1775 = xor i1 %1774, true
  %1776 = xor i1 %1775, true
  %1777 = zext i1 %1776 to i32
  %1778 = sext i32 %1777 to i64
  %1779 = call i64 @llvm.expect.i64(i64 %1778, i64 0)
  %1780 = icmp ne i64 %1779, 0
  br i1 %1780, label %1781, label %1782

1781:                                             ; preds = %1770
  store i32 14, ptr %23, align 4
  br label %1784

1782:                                             ; preds = %1770
  br label %1783

1783:                                             ; preds = %1782, %1747
  store i32 0, ptr %23, align 4
  br label %1784

1784:                                             ; preds = %1783, %1781, %1769
  call void @llvm.lifetime.end.p0(i64 8, ptr %44) #10
  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
  %1785 = load i32, ptr %23, align 4
  switch i32 %1785, label %4629 [
    i32 0, label %1786
    i32 14, label %4523
  ]

1786:                                             ; preds = %1784
  br label %2230

1787:                                             ; preds = %1048
  %1788 = load ptr, ptr %7, align 8, !tbaa !5
  %1789 = getelementptr inbounds %struct.MDBX_cursor, ptr %1788, i32 0, i32 5
  %1790 = load ptr, ptr %1789, align 8, !tbaa !11
  %1791 = call ptr @page_shadow_alloc(ptr noundef %1790, i64 noundef 1)
  store ptr %1791, ptr %18, align 8, !tbaa !5
  %1792 = load ptr, ptr %18, align 8, !tbaa !5
  %1793 = icmp eq ptr %1792, null
  %1794 = xor i1 %1793, true
  %1795 = xor i1 %1794, true
  %1796 = zext i1 %1795 to i32
  %1797 = sext i32 %1796 to i64
  %1798 = call i64 @llvm.expect.i64(i64 %1797, i64 0)
  %1799 = icmp ne i64 %1798, 0
  br i1 %1799, label %1800, label %1801

1800:                                             ; preds = %1787
  store i32 12, ptr %13, align 4, !tbaa !9
  br label %4523

1801:                                             ; preds = %1787
  call void @llvm.lifetime.start.p0(i64 8, ptr %47) #10
  %1802 = load ptr, ptr %15, align 8, !tbaa !5
  %1803 = call i64 @page_space(ptr noundef %1802) #12
  store i64 %1803, ptr %47, align 8, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 8, ptr %48) #10
  %1804 = load ptr, ptr %20, align 8, !tbaa !5
  %1805 = call zeroext i1 @is_leaf(ptr noundef %1804) #12
  br i1 %1805, label %1806, label %1811

1806:                                             ; preds = %1801
  %1807 = load ptr, ptr %15, align 8, !tbaa !5
  %1808 = load ptr, ptr %8, align 8, !tbaa !5
  %1809 = load ptr, ptr %9, align 8, !tbaa !5
  %1810 = call i64 @leaf_size(ptr noundef %1807, ptr noundef %1808, ptr noundef %1809) #12
  br label %1815

1811:                                             ; preds = %1801
  %1812 = load ptr, ptr %15, align 8, !tbaa !5
  %1813 = load ptr, ptr %8, align 8, !tbaa !5
  %1814 = call i64 @branch_size(ptr noundef %1812, ptr noundef %1813) #12
  br label %1815

1815:                                             ; preds = %1811, %1806
  %1816 = phi i64 [ %1810, %1806 ], [ %1814, %1811 ]
  store i64 %1816, ptr %48, align 8, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 8, ptr %49) #10
  store i64 0, ptr %49, align 8, !tbaa !24
  br label %1817

1817:                                             ; preds = %1821, %1815
  %1818 = load i64, ptr %49, align 8, !tbaa !24
  %1819 = load i64, ptr %21, align 8, !tbaa !24
  %1820 = icmp ult i64 %1818, %1819
  br i1 %1820, label %1821, label %1833

1821:                                             ; preds = %1817
  %1822 = load ptr, ptr %20, align 8, !tbaa !5
  %1823 = getelementptr inbounds %struct.page, ptr %1822, i32 0, i32 5
  %1824 = load i64, ptr %49, align 8, !tbaa !24
  %1825 = getelementptr inbounds [0 x i16], ptr %1823, i64 0, i64 %1824
  %1826 = load i16, ptr %1825, align 1, !tbaa !23
  %1827 = load ptr, ptr %18, align 8, !tbaa !5
  %1828 = getelementptr inbounds %struct.page, ptr %1827, i32 0, i32 5
  %1829 = load i64, ptr %49, align 8, !tbaa !24
  %1830 = getelementptr inbounds [0 x i16], ptr %1828, i64 0, i64 %1829
  store i16 %1826, ptr %1830, align 1, !tbaa !23
  %1831 = load i64, ptr %49, align 8, !tbaa !24
  %1832 = add i64 %1831, 1
  store i64 %1832, ptr %49, align 8, !tbaa !24
  br label %1817, !llvm.loop !48

1833:                                             ; preds = %1817
  %1834 = load ptr, ptr %18, align 8, !tbaa !5
  %1835 = getelementptr inbounds %struct.page, ptr %1834, i32 0, i32 5
  %1836 = load i64, ptr %49, align 8, !tbaa !24
  %1837 = getelementptr inbounds [0 x i16], ptr %1835, i64 0, i64 %1836
  store i16 -1, ptr %1837, align 1, !tbaa !23
  br label %1838

1838:                                             ; preds = %1843, %1833
  %1839 = load i64, ptr %49, align 8, !tbaa !24
  %1840 = add i64 %1839, 1
  store i64 %1840, ptr %49, align 8, !tbaa !24
  %1841 = load i64, ptr %22, align 8, !tbaa !24
  %1842 = icmp ule i64 %1840, %1841
  br i1 %1842, label %1843, label %1854

1843:                                             ; preds = %1838
  %1844 = load ptr, ptr %20, align 8, !tbaa !5
  %1845 = getelementptr inbounds %struct.page, ptr %1844, i32 0, i32 5
  %1846 = load i64, ptr %49, align 8, !tbaa !24
  %1847 = sub i64 %1846, 1
  %1848 = getelementptr inbounds [0 x i16], ptr %1845, i64 0, i64 %1847
  %1849 = load i16, ptr %1848, align 1, !tbaa !23
  %1850 = load ptr, ptr %18, align 8, !tbaa !5
  %1851 = getelementptr inbounds %struct.page, ptr %1850, i32 0, i32 5
  %1852 = load i64, ptr %49, align 8, !tbaa !24
  %1853 = getelementptr inbounds [0 x i16], ptr %1851, i64 0, i64 %1852
  store i16 %1849, ptr %1853, align 1, !tbaa !23
  br label %1838, !llvm.loop !49

1854:                                             ; preds = %1838
  %1855 = load ptr, ptr %20, align 8, !tbaa !5
  %1856 = getelementptr inbounds %struct.page, ptr %1855, i32 0, i32 4
  %1857 = load i32, ptr %1856, align 1, !tbaa !9
  %1858 = load ptr, ptr %18, align 8, !tbaa !5
  %1859 = getelementptr inbounds %struct.page, ptr %1858, i32 0, i32 4
  store i32 %1857, ptr %1859, align 1, !tbaa !9
  %1860 = load ptr, ptr %20, align 8, !tbaa !5
  %1861 = getelementptr inbounds %struct.page, ptr %1860, i32 0, i32 2
  %1862 = load i16, ptr %1861, align 1, !tbaa !23
  %1863 = load ptr, ptr %18, align 8, !tbaa !5
  %1864 = getelementptr inbounds %struct.page, ptr %1863, i32 0, i32 2
  store i16 %1862, ptr %1864, align 1, !tbaa !23
  %1865 = load ptr, ptr %18, align 8, !tbaa !5
  %1866 = getelementptr inbounds %struct.page, ptr %1865, i32 0, i32 0
  store i64 -1, ptr %1866, align 1, !tbaa !24
  %1867 = load ptr, ptr %18, align 8, !tbaa !5
  %1868 = getelementptr inbounds %struct.page, ptr %1867, i32 0, i32 3
  %1869 = getelementptr inbounds %struct.anon.19, ptr %1868, i32 0, i32 0
  store i16 0, ptr %1869, align 1, !tbaa !19
  %1870 = load i64, ptr %47, align 8, !tbaa !24
  %1871 = trunc i64 %1870 to i16
  %1872 = load ptr, ptr %18, align 8, !tbaa !5
  %1873 = getelementptr inbounds %struct.page, ptr %1872, i32 0, i32 3
  %1874 = getelementptr inbounds %struct.anon.19, ptr %1873, i32 0, i32 1
  store i16 %1871, ptr %1874, align 1, !tbaa !19
  %1875 = load i64, ptr %21, align 8, !tbaa !24
  %1876 = load i64, ptr %32, align 8, !tbaa !24
  %1877 = icmp eq i64 %1875, %1876
  br i1 %1877, label %1878, label %1890

1878:                                             ; preds = %1854
  %1879 = load i64, ptr %22, align 8, !tbaa !24
  %1880 = icmp uge i64 %1879, 5
  br i1 %1880, label %1881, label %1890

1881:                                             ; preds = %1878
  %1882 = load ptr, ptr %20, align 8, !tbaa !5
  %1883 = getelementptr inbounds %struct.page, ptr %1882, i32 0, i32 2
  %1884 = load i16, ptr %1883, align 1, !tbaa !23
  %1885 = zext i16 %1884 to i32
  %1886 = and i32 %1885, 1
  %1887 = sext i32 %1886 to i64
  %1888 = load i64, ptr %32, align 8, !tbaa !24
  %1889 = add i64 %1888, %1887
  store i64 %1889, ptr %32, align 8, !tbaa !24
  br label %1890

1890:                                             ; preds = %1881, %1878, %1854
  br label %1891

1891:                                             ; preds = %1890
  %1892 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %1893 = zext i8 %1892 to i32
  %1894 = and i32 %1893, 1
  %1895 = icmp ne i32 %1894, 0
  %1896 = xor i1 %1895, true
  %1897 = xor i1 %1896, true
  %1898 = zext i1 %1897 to i32
  %1899 = sext i32 %1898 to i64
  %1900 = call i64 @llvm.expect.i64(i64 %1899, i64 1)
  %1901 = icmp ne i64 %1900, 0
  br i1 %1901, label %1902, label %1928

1902:                                             ; preds = %1891
  br label %1903

1903:                                             ; preds = %1902
  %1904 = load i64, ptr %32, align 8, !tbaa !24
  %1905 = load i64, ptr %24, align 8, !tbaa !24
  %1906 = icmp uge i64 %1904, %1905
  br i1 %1906, label %1907, label %1914

1907:                                             ; preds = %1903
  %1908 = load i64, ptr %32, align 8, !tbaa !24
  %1909 = load i64, ptr %22, align 8, !tbaa !24
  %1910 = add i64 %1909, 1
  %1911 = load i64, ptr %24, align 8, !tbaa !24
  %1912 = sub i64 %1910, %1911
  %1913 = icmp ule i64 %1908, %1912
  br label %1914

1914:                                             ; preds = %1907, %1903
  %1915 = phi i1 [ false, %1903 ], [ %1913, %1907 ]
  %1916 = xor i1 %1915, true
  %1917 = xor i1 %1916, true
  %1918 = xor i1 %1917, true
  %1919 = zext i1 %1918 to i32
  %1920 = sext i32 %1919 to i64
  %1921 = call i64 @llvm.expect.i64(i64 %1920, i64 0)
  %1922 = icmp ne i64 %1921, 0
  br i1 %1922, label %1923, label %1925

1923:                                             ; preds = %1914
  %1924 = load ptr, ptr %15, align 8, !tbaa !5
  call void @mdbx_assert_fail(ptr noundef %1924, ptr noundef @.str.69, ptr noundef @__func__.page_split, i32 noundef 1174) #11
  unreachable

1925:                                             ; preds = %1914
  br label %1926

1926:                                             ; preds = %1925
  br label %1927

1927:                                             ; preds = %1926
  br label %1928

1928:                                             ; preds = %1927, %1891
  br label %1929

1929:                                             ; preds = %1928
  br label %1930

1930:                                             ; preds = %1929
  call void @llvm.lifetime.start.p0(i64 8, ptr %50) #10
  %1931 = load i64, ptr %21, align 8, !tbaa !24
  %1932 = load i64, ptr %32, align 8, !tbaa !24
  %1933 = icmp uge i64 %1931, %1932
  br i1 %1933, label %1934, label %1936

1934:                                             ; preds = %1930
  %1935 = load i64, ptr %32, align 8, !tbaa !24
  br label %1940

1936:                                             ; preds = %1930
  %1937 = load i64, ptr %22, align 8, !tbaa !24
  %1938 = load i64, ptr %32, align 8, !tbaa !24
  %1939 = sub i64 %1937, %1938
  br label %1940

1940:                                             ; preds = %1936, %1934
  %1941 = phi i64 [ %1935, %1934 ], [ %1939, %1936 ]
  store i64 %1941, ptr %50, align 8, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 8, ptr %51) #10
  %1942 = load i64, ptr %50, align 8, !tbaa !24
  %1943 = mul i64 11, %1942
  store i64 %1943, ptr %51, align 8, !tbaa !24
  %1944 = load i64, ptr %48, align 8, !tbaa !24
  %1945 = load i64, ptr %51, align 8, !tbaa !24
  %1946 = icmp uge i64 %1944, %1945
  br i1 %1946, label %1947, label %2165

1947:                                             ; preds = %1940
  %1948 = load i64, ptr %21, align 8, !tbaa !24
  %1949 = load i64, ptr %32, align 8, !tbaa !24
  %1950 = icmp ult i64 %1948, %1949
  br i1 %1950, label %1951, label %1952

1951:                                             ; preds = %1947
  br label %1954

1952:                                             ; preds = %1947
  %1953 = load i64, ptr %22, align 8, !tbaa !24
  br label %1954

1954:                                             ; preds = %1952, %1951
  %1955 = phi i64 [ 0, %1951 ], [ %1953, %1952 ]
  store i64 %1955, ptr %49, align 8, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 8, ptr %52) #10
  %1956 = load i64, ptr %21, align 8, !tbaa !24
  %1957 = load i64, ptr %32, align 8, !tbaa !24
  %1958 = icmp ult i64 %1956, %1957
  %1959 = zext i1 %1958 to i64
  %1960 = select i1 %1958, i32 1, i32 -1
  %1961 = sext i32 %1960 to i64
  store i64 %1961, ptr %52, align 8, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 8, ptr %53) #10
  store i64 0, ptr %53, align 8, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 8, ptr %54) #10
  %1962 = load i64, ptr %48, align 8, !tbaa !24
  %1963 = load ptr, ptr %15, align 8, !tbaa !5
  %1964 = load ptr, ptr %20, align 8, !tbaa !5
  %1965 = call i64 @page_used(ptr noundef %1963, ptr noundef %1964) #12
  %1966 = add i64 %1962, %1965
  store i64 %1966, ptr %54, align 8, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 8, ptr %55) #10
  %1967 = load i64, ptr %32, align 8, !tbaa !24
  store i64 %1967, ptr %55, align 8, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 8, ptr %56) #10
  store i64 2147483647, ptr %56, align 8, !tbaa !24
  br label %1968

1968:                                             ; preds = %1954
  %1969 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 5), align 2, !tbaa !25
  %1970 = zext i8 %1969 to i32
  %1971 = icmp sle i32 6, %1970
  %1972 = xor i1 %1971, true
  %1973 = xor i1 %1972, true
  %1974 = zext i1 %1973 to i32
  %1975 = sext i32 %1974 to i64
  %1976 = call i64 @llvm.expect.i64(i64 %1975, i64 0)
  %1977 = icmp ne i64 %1976, 0
  br i1 %1977, label %1978, label %1984

1978:                                             ; preds = %1968
  %1979 = load i64, ptr %49, align 8, !tbaa !24
  %1980 = load i64, ptr %52, align 8, !tbaa !24
  %1981 = load i64, ptr %32, align 8, !tbaa !24
  %1982 = load i64, ptr %21, align 8, !tbaa !24
  %1983 = load i64, ptr %48, align 8, !tbaa !24
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef @__func__.page_split, i32 noundef 1187, ptr noundef @.str.70, i64 noundef %1979, i64 noundef %1980, i64 noundef %1981, i64 noundef %1982, i64 noundef %1983)
  br label %1984

1984:                                             ; preds = %1978, %1968
  br label %1985

1985:                                             ; preds = %1984
  br label %1986

1986:                                             ; preds = %1985
  br label %1987

1987:                                             ; preds = %2144, %1986
  br label %1988

1988:                                             ; preds = %1987
  %1989 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %1990 = zext i8 %1989 to i32
  %1991 = and i32 %1990, 1
  %1992 = icmp ne i32 %1991, 0
  %1993 = xor i1 %1992, true
  %1994 = xor i1 %1993, true
  %1995 = zext i1 %1994 to i32
  %1996 = sext i32 %1995 to i64
  %1997 = call i64 @llvm.expect.i64(i64 %1996, i64 1)
  %1998 = icmp ne i64 %1997, 0
  br i1 %1998, label %1999, label %2020

1999:                                             ; preds = %1988
  br label %2000

2000:                                             ; preds = %1999
  %2001 = load i64, ptr %49, align 8, !tbaa !24
  %2002 = load i64, ptr %22, align 8, !tbaa !24
  %2003 = icmp ule i64 %2001, %2002
  %2004 = xor i1 %2003, true
  %2005 = xor i1 %2004, true
  %2006 = xor i1 %2005, true
  %2007 = zext i1 %2006 to i32
  %2008 = sext i32 %2007 to i64
  %2009 = call i64 @llvm.expect.i64(i64 %2008, i64 0)
  %2010 = icmp ne i64 %2009, 0
  br i1 %2010, label %2011, label %2017

2011:                                             ; preds = %2000
  %2012 = load ptr, ptr %7, align 8, !tbaa !5
  %2013 = getelementptr inbounds %struct.MDBX_cursor, ptr %2012, i32 0, i32 5
  %2014 = load ptr, ptr %2013, align 8, !tbaa !11
  %2015 = getelementptr inbounds %struct.MDBX_txn, ptr %2014, i32 0, i32 9
  %2016 = load ptr, ptr %2015, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %2016, ptr noundef @.str.71, ptr noundef @__func__.page_split, i32 noundef 1189) #11
  unreachable

2017:                                             ; preds = %2000
  br label %2018

2018:                                             ; preds = %2017
  br label %2019

2019:                                             ; preds = %2018
  br label %2020

2020:                                             ; preds = %2019, %1988
  br label %2021

2021:                                             ; preds = %2020
  br label %2022

2022:                                             ; preds = %2021
  call void @llvm.lifetime.start.p0(i64 8, ptr %57) #10
  %2023 = load i64, ptr %48, align 8, !tbaa !24
  store i64 %2023, ptr %57, align 8, !tbaa !24
  %2024 = load i64, ptr %49, align 8, !tbaa !24
  %2025 = load i64, ptr %21, align 8, !tbaa !24
  %2026 = icmp ne i64 %2024, %2025
  br i1 %2026, label %2027, label %2064

2027:                                             ; preds = %2022
  call void @llvm.lifetime.start.p0(i64 8, ptr %58) #10
  %2028 = load ptr, ptr %20, align 8, !tbaa !5
  %2029 = ptrtoint ptr %2028 to i64
  %2030 = load ptr, ptr %18, align 8, !tbaa !5
  %2031 = getelementptr inbounds %struct.page, ptr %2030, i32 0, i32 5
  %2032 = load i64, ptr %49, align 8, !tbaa !24
  %2033 = getelementptr inbounds [0 x i16], ptr %2031, i64 0, i64 %2032
  %2034 = load i16, ptr %2033, align 1, !tbaa !23
  %2035 = zext i16 %2034 to i32
  %2036 = add i32 %2035, 20
  %2037 = zext i32 %2036 to i64
  %2038 = add nsw i64 %2029, %2037
  %2039 = inttoptr i64 %2038 to ptr
  store ptr %2039, ptr %58, align 8, !tbaa !5
  %2040 = load ptr, ptr %58, align 8, !tbaa !5
  %2041 = call i64 @node_ks(ptr noundef %2040) #12
  %2042 = add i64 8, %2041
  %2043 = add i64 %2042, 2
  store i64 %2043, ptr %57, align 8, !tbaa !24
  %2044 = load ptr, ptr %20, align 8, !tbaa !5
  %2045 = call zeroext i1 @is_leaf(ptr noundef %2044) #12
  br i1 %2045, label %2046, label %2060

2046:                                             ; preds = %2027
  %2047 = load ptr, ptr %58, align 8, !tbaa !5
  %2048 = call zeroext i8 @node_flags(ptr noundef %2047) #12
  %2049 = zext i8 %2048 to i32
  %2050 = and i32 %2049, 1
  %2051 = icmp ne i32 %2050, 0
  br i1 %2051, label %2052, label %2053

2052:                                             ; preds = %2046
  br label %2056

2053:                                             ; preds = %2046
  %2054 = load ptr, ptr %58, align 8, !tbaa !5
  %2055 = call i64 @node_ds(ptr noundef %2054) #12
  br label %2056

2056:                                             ; preds = %2053, %2052
  %2057 = phi i64 [ 4, %2052 ], [ %2055, %2053 ]
  %2058 = load i64, ptr %57, align 8, !tbaa !24
  %2059 = add i64 %2058, %2057
  store i64 %2059, ptr %57, align 8, !tbaa !24
  br label %2060

2060:                                             ; preds = %2056, %2027
  %2061 = load i64, ptr %57, align 8, !tbaa !24
  %2062 = add i64 %2061, 1
  %2063 = and i64 %2062, -2
  store i64 %2063, ptr %57, align 8, !tbaa !24
  call void @llvm.lifetime.end.p0(i64 8, ptr %58) #10
  br label %2064

2064:                                             ; preds = %2060, %2022
  %2065 = load i64, ptr %57, align 8, !tbaa !24
  %2066 = load i64, ptr %53, align 8, !tbaa !24
  %2067 = add i64 %2066, %2065
  store i64 %2067, ptr %53, align 8, !tbaa !24
  %2068 = load i64, ptr %57, align 8, !tbaa !24
  %2069 = load i64, ptr %54, align 8, !tbaa !24
  %2070 = sub i64 %2069, %2068
  store i64 %2070, ptr %54, align 8, !tbaa !24
  br label %2071

2071:                                             ; preds = %2064
  %2072 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 5), align 2, !tbaa !25
  %2073 = zext i8 %2072 to i32
  %2074 = icmp sle i32 6, %2073
  %2075 = xor i1 %2074, true
  %2076 = xor i1 %2075, true
  %2077 = zext i1 %2076 to i32
  %2078 = sext i32 %2077 to i64
  %2079 = call i64 @llvm.expect.i64(i64 %2078, i64 0)
  %2080 = icmp ne i64 %2079, 0
  br i1 %2080, label %2081, label %2087

2081:                                             ; preds = %2071
  %2082 = load i64, ptr %49, align 8, !tbaa !24
  %2083 = load i64, ptr %57, align 8, !tbaa !24
  %2084 = load i64, ptr %53, align 8, !tbaa !24
  %2085 = load i64, ptr %54, align 8, !tbaa !24
  %2086 = load i64, ptr %47, align 8, !tbaa !24
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef @__func__.page_split, i32 noundef 1201, ptr noundef @.str.72, i64 noundef %2082, i64 noundef %2083, i64 noundef %2084, i64 noundef %2085, i64 noundef %2086)
  br label %2087

2087:                                             ; preds = %2081, %2071
  br label %2088

2088:                                             ; preds = %2087
  br label %2089

2089:                                             ; preds = %2088
  %2090 = load i64, ptr %53, align 8, !tbaa !24
  %2091 = load i64, ptr %47, align 8, !tbaa !24
  %2092 = icmp ule i64 %2090, %2091
  br i1 %2092, label %2093, label %2137

2093:                                             ; preds = %2089
  %2094 = load i64, ptr %54, align 8, !tbaa !24
  %2095 = load i64, ptr %47, align 8, !tbaa !24
  %2096 = icmp ule i64 %2094, %2095
  br i1 %2096, label %2097, label %2137

2097:                                             ; preds = %2093
  call void @llvm.lifetime.start.p0(i64 8, ptr %59) #10
  %2098 = load i64, ptr %49, align 8, !tbaa !24
  %2099 = load i64, ptr %52, align 8, !tbaa !24
  %2100 = icmp sgt i64 %2099, 0
  %2101 = zext i1 %2100 to i32
  %2102 = sext i32 %2101 to i64
  %2103 = add i64 %2098, %2102
  store i64 %2103, ptr %59, align 8, !tbaa !24
  %2104 = load i64, ptr %59, align 8, !tbaa !24
  %2105 = load i64, ptr %24, align 8, !tbaa !24
  %2106 = icmp uge i64 %2104, %2105
  br i1 %2106, label %2107, label %2133

2107:                                             ; preds = %2097
  %2108 = load i64, ptr %59, align 8, !tbaa !24
  %2109 = load i64, ptr %22, align 8, !tbaa !24
  %2110 = add i64 %2109, 1
  %2111 = load i64, ptr %24, align 8, !tbaa !24
  %2112 = sub i64 %2110, %2111
  %2113 = icmp ule i64 %2108, %2112
  br i1 %2113, label %2114, label %2133

2114:                                             ; preds = %2107
  call void @llvm.lifetime.start.p0(i64 8, ptr %60) #10
  %2115 = load i64, ptr %32, align 8, !tbaa !24
  %2116 = load i64, ptr %59, align 8, !tbaa !24
  %2117 = sub i64 %2115, %2116
  %2118 = call i64 @branchless_abs(i64 noundef %2117) #13
  store i64 %2118, ptr %60, align 8, !tbaa !24
  %2119 = load i64, ptr %60, align 8, !tbaa !24
  %2120 = load i64, ptr %56, align 8, !tbaa !24
  %2121 = icmp uge i64 %2119, %2120
  br i1 %2121, label %2122, label %2123

2122:                                             ; preds = %2114
  store i32 114, ptr %23, align 4
  br label %2130

2123:                                             ; preds = %2114
  %2124 = load i64, ptr %60, align 8, !tbaa !24
  store i64 %2124, ptr %56, align 8, !tbaa !24
  %2125 = load i64, ptr %59, align 8, !tbaa !24
  store i64 %2125, ptr %55, align 8, !tbaa !24
  %2126 = load i64, ptr %56, align 8, !tbaa !24
  %2127 = icmp ne i64 %2126, 0
  br i1 %2127, label %2129, label %2128

2128:                                             ; preds = %2123
  store i32 114, ptr %23, align 4
  br label %2130

2129:                                             ; preds = %2123
  store i32 0, ptr %23, align 4
  br label %2130

2130:                                             ; preds = %2129, %2128, %2122
  call void @llvm.lifetime.end.p0(i64 8, ptr %60) #10
  %2131 = load i32, ptr %23, align 4
  switch i32 %2131, label %2134 [
    i32 0, label %2132
  ]

2132:                                             ; preds = %2130
  br label %2133

2133:                                             ; preds = %2132, %2107, %2097
  store i32 0, ptr %23, align 4
  br label %2134

2134:                                             ; preds = %2133, %2130
  call void @llvm.lifetime.end.p0(i64 8, ptr %59) #10
  %2135 = load i32, ptr %23, align 4
  switch i32 %2135, label %2141 [
    i32 0, label %2136
  ]

2136:                                             ; preds = %2134
  br label %2137

2137:                                             ; preds = %2136, %2093, %2089
  %2138 = load i64, ptr %52, align 8, !tbaa !24
  %2139 = load i64, ptr %49, align 8, !tbaa !24
  %2140 = add i64 %2139, %2138
  store i64 %2140, ptr %49, align 8, !tbaa !24
  store i32 0, ptr %23, align 4
  br label %2141

2141:                                             ; preds = %2137, %2134
  call void @llvm.lifetime.end.p0(i64 8, ptr %57) #10
  %2142 = load i32, ptr %23, align 4
  switch i32 %2142, label %4633 [
    i32 0, label %2143
    i32 114, label %2148
  ]

2143:                                             ; preds = %2141
  br label %2144

2144:                                             ; preds = %2143
  %2145 = load i64, ptr %49, align 8, !tbaa !24
  %2146 = load i64, ptr %22, align 8, !tbaa !24
  %2147 = icmp ult i64 %2145, %2146
  br i1 %2147, label %1987, label %2148, !llvm.loop !50

2148:                                             ; preds = %2144, %2141
  %2149 = load i64, ptr %55, align 8, !tbaa !24
  store i64 %2149, ptr %32, align 8, !tbaa !24
  br label %2150

2150:                                             ; preds = %2148
  %2151 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 5), align 2, !tbaa !25
  %2152 = zext i8 %2151 to i32
  %2153 = icmp sle i32 6, %2152
  %2154 = xor i1 %2153, true
  %2155 = xor i1 %2154, true
  %2156 = zext i1 %2155 to i32
  %2157 = sext i32 %2156 to i64
  %2158 = call i64 @llvm.expect.i64(i64 %2157, i64 0)
  %2159 = icmp ne i64 %2158, 0
  br i1 %2159, label %2160, label %2162

2160:                                             ; preds = %2150
  %2161 = load i64, ptr %32, align 8, !tbaa !24
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef @__func__.page_split, i32 noundef 1219, ptr noundef @.str.73, i64 noundef %2161)
  br label %2162

2162:                                             ; preds = %2160, %2150
  br label %2163

2163:                                             ; preds = %2162
  br label %2164

2164:                                             ; preds = %2163
  call void @llvm.lifetime.end.p0(i64 8, ptr %56) #10
  call void @llvm.lifetime.end.p0(i64 8, ptr %55) #10
  call void @llvm.lifetime.end.p0(i64 8, ptr %54) #10
  call void @llvm.lifetime.end.p0(i64 8, ptr %53) #10
  call void @llvm.lifetime.end.p0(i64 8, ptr %52) #10
  br label %2165

2165:                                             ; preds = %2164, %1940
  br label %2166

2166:                                             ; preds = %2165
  %2167 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %2168 = zext i8 %2167 to i32
  %2169 = and i32 %2168, 1
  %2170 = icmp ne i32 %2169, 0
  %2171 = xor i1 %2170, true
  %2172 = xor i1 %2171, true
  %2173 = zext i1 %2172 to i32
  %2174 = sext i32 %2173 to i64
  %2175 = call i64 @llvm.expect.i64(i64 %2174, i64 1)
  %2176 = icmp ne i64 %2175, 0
  br i1 %2176, label %2177, label %2203

2177:                                             ; preds = %2166
  br label %2178

2178:                                             ; preds = %2177
  %2179 = load i64, ptr %32, align 8, !tbaa !24
  %2180 = load i64, ptr %24, align 8, !tbaa !24
  %2181 = icmp uge i64 %2179, %2180
  br i1 %2181, label %2182, label %2189

2182:                                             ; preds = %2178
  %2183 = load i64, ptr %32, align 8, !tbaa !24
  %2184 = load i64, ptr %22, align 8, !tbaa !24
  %2185 = add i64 %2184, 1
  %2186 = load i64, ptr %24, align 8, !tbaa !24
  %2187 = sub i64 %2185, %2186
  %2188 = icmp ule i64 %2183, %2187
  br label %2189

2189:                                             ; preds = %2182, %2178
  %2190 = phi i1 [ false, %2178 ], [ %2188, %2182 ]
  %2191 = xor i1 %2190, true
  %2192 = xor i1 %2191, true
  %2193 = xor i1 %2192, true
  %2194 = zext i1 %2193 to i32
  %2195 = sext i32 %2194 to i64
  %2196 = call i64 @llvm.expect.i64(i64 %2195, i64 0)
  %2197 = icmp ne i64 %2196, 0
  br i1 %2197, label %2198, label %2200

2198:                                             ; preds = %2189
  %2199 = load ptr, ptr %15, align 8, !tbaa !5
  call void @mdbx_assert_fail(ptr noundef %2199, ptr noundef @.str.69, ptr noundef @__func__.page_split, i32 noundef 1221) #11
  unreachable

2200:                                             ; preds = %2189
  br label %2201

2201:                                             ; preds = %2200
  br label %2202

2202:                                             ; preds = %2201
  br label %2203

2203:                                             ; preds = %2202, %2166
  br label %2204

2204:                                             ; preds = %2203
  br label %2205

2205:                                             ; preds = %2204
  %2206 = load ptr, ptr %8, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %33, ptr align 8 %2206, i64 16, i1 false), !tbaa.struct !36
  %2207 = load i64, ptr %32, align 8, !tbaa !24
  %2208 = load i64, ptr %21, align 8, !tbaa !24
  %2209 = icmp ne i64 %2207, %2208
  br i1 %2209, label %2210, label %2229

2210:                                             ; preds = %2205
  call void @llvm.lifetime.start.p0(i64 8, ptr %61) #10
  %2211 = load ptr, ptr %20, align 8, !tbaa !5
  %2212 = ptrtoint ptr %2211 to i64
  %2213 = load ptr, ptr %18, align 8, !tbaa !5
  %2214 = getelementptr inbounds %struct.page, ptr %2213, i32 0, i32 5
  %2215 = load i64, ptr %32, align 8, !tbaa !24
  %2216 = getelementptr inbounds [0 x i16], ptr %2214, i64 0, i64 %2215
  %2217 = load i16, ptr %2216, align 1, !tbaa !23
  %2218 = zext i16 %2217 to i32
  %2219 = add i32 %2218, 20
  %2220 = zext i32 %2219 to i64
  %2221 = add nsw i64 %2212, %2220
  %2222 = inttoptr i64 %2221 to ptr
  store ptr %2222, ptr %61, align 8, !tbaa !5
  %2223 = load ptr, ptr %61, align 8, !tbaa !5
  %2224 = call i64 @node_ks(ptr noundef %2223) #12
  %2225 = getelementptr inbounds %struct.iovec, ptr %33, i32 0, i32 1
  store i64 %2224, ptr %2225, align 8, !tbaa !26
  %2226 = load ptr, ptr %61, align 8, !tbaa !5
  %2227 = call ptr @node_key(ptr noundef %2226) #12
  %2228 = getelementptr inbounds %struct.iovec, ptr %33, i32 0, i32 0
  store ptr %2227, ptr %2228, align 8, !tbaa !47
  call void @llvm.lifetime.end.p0(i64 8, ptr %61) #10
  br label %2229

2229:                                             ; preds = %2210, %2205
  call void @llvm.lifetime.end.p0(i64 8, ptr %51) #10
  call void @llvm.lifetime.end.p0(i64 8, ptr %50) #10
  call void @llvm.lifetime.end.p0(i64 8, ptr %49) #10
  call void @llvm.lifetime.end.p0(i64 8, ptr %48) #10
  call void @llvm.lifetime.end.p0(i64 8, ptr %47) #10
  br label %2230

2230:                                             ; preds = %2229, %1786
  br label %2231

2231:                                             ; preds = %2230, %1047
  br label %2232

2232:                                             ; preds = %2231, %964
  br label %2233

2233:                                             ; preds = %2232
  %2234 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 5), align 2, !tbaa !25
  %2235 = zext i8 %2234 to i32
  %2236 = icmp sle i32 5, %2235
  %2237 = xor i1 %2236, true
  %2238 = xor i1 %2237, true
  %2239 = zext i1 %2238 to i32
  %2240 = sext i32 %2239 to i64
  %2241 = call i64 @llvm.expect.i64(i64 %2240, i64 0)
  %2242 = icmp ne i64 %2241, 0
  br i1 %2242, label %2243, label %2247

2243:                                             ; preds = %2233
  %2244 = load i64, ptr %32, align 8, !tbaa !24
  %2245 = getelementptr inbounds [510 x i8], ptr %19, i64 0, i64 0
  %2246 = call ptr @mdbx_dump_val(ptr noundef %33, ptr noundef %2245, i64 noundef 255)
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 5, ptr noundef @__func__.page_split, i32 noundef 1231, ptr noundef @.str.74, i64 noundef %2244, ptr noundef %2246)
  br label %2247

2247:                                             ; preds = %2243, %2233
  br label %2248

2248:                                             ; preds = %2247
  br label %2249

2249:                                             ; preds = %2248
  store i8 0, ptr %62, align 1, !tbaa !44
  %2250 = load ptr, ptr %31, align 8, !tbaa !5
  %2251 = getelementptr inbounds %struct.MDBX_cursor, ptr %2250, i32 0, i32 9
  %2252 = load i64, ptr %27, align 8, !tbaa !24
  %2253 = getelementptr inbounds [32 x ptr], ptr %2251, i64 0, i64 %2252
  %2254 = load ptr, ptr %2253, align 8, !tbaa !5
  %2255 = call i64 @page_room(ptr noundef %2254) #12
  %2256 = load ptr, ptr %15, align 8, !tbaa !5
  %2257 = call i64 @branch_size(ptr noundef %2256, ptr noundef %33) #12
  %2258 = icmp ult i64 %2255, %2257
  br i1 %2258, label %2259, label %2673

2259:                                             ; preds = %2249
  br label %2260

2260:                                             ; preds = %2259
  %2261 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 5), align 2, !tbaa !25
  %2262 = zext i8 %2261 to i32
  %2263 = icmp sle i32 6, %2262
  %2264 = xor i1 %2263, true
  %2265 = xor i1 %2264, true
  %2266 = zext i1 %2265 to i32
  %2267 = sext i32 %2266 to i64
  %2268 = call i64 @llvm.expect.i64(i64 %2267, i64 0)
  %2269 = icmp ne i64 %2268, 0
  br i1 %2269, label %2270, label %2273

2270:                                             ; preds = %2260
  %2271 = getelementptr inbounds [510 x i8], ptr %19, i64 0, i64 0
  %2272 = call ptr @mdbx_dump_val(ptr noundef %33, ptr noundef %2271, i64 noundef 255)
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef @__func__.page_split, i32 noundef 1236, ptr noundef @.str.75, ptr noundef %2272)
  br label %2273

2273:                                             ; preds = %2270, %2260
  br label %2274

2274:                                             ; preds = %2273
  br label %2275

2275:                                             ; preds = %2274
  br label %2276

2276:                                             ; preds = %2275
  %2277 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %2278 = zext i8 %2277 to i32
  %2279 = and i32 %2278, 1
  %2280 = icmp ne i32 %2279, 0
  %2281 = xor i1 %2280, true
  %2282 = xor i1 %2281, true
  %2283 = zext i1 %2282 to i32
  %2284 = sext i32 %2283 to i64
  %2285 = call i64 @llvm.expect.i64(i64 %2284, i64 1)
  %2286 = icmp ne i64 %2285, 0
  br i1 %2286, label %2287, label %2312

2287:                                             ; preds = %2276
  br label %2288

2288:                                             ; preds = %2287
  %2289 = load ptr, ptr %31, align 8, !tbaa !5
  %2290 = getelementptr inbounds %struct.MDBX_cursor, ptr %2289, i32 0, i32 9
  %2291 = load i64, ptr %27, align 8, !tbaa !24
  %2292 = getelementptr inbounds [32 x ptr], ptr %2290, i64 0, i64 %2291
  %2293 = load ptr, ptr %2292, align 8, !tbaa !5
  %2294 = call i64 @page_numkeys(ptr noundef %2293) #12
  %2295 = icmp ugt i64 %2294, 2
  %2296 = xor i1 %2295, true
  %2297 = xor i1 %2296, true
  %2298 = xor i1 %2297, true
  %2299 = zext i1 %2298 to i32
  %2300 = sext i32 %2299 to i64
  %2301 = call i64 @llvm.expect.i64(i64 %2300, i64 0)
  %2302 = icmp ne i64 %2301, 0
  br i1 %2302, label %2303, label %2309

2303:                                             ; preds = %2288
  %2304 = load ptr, ptr %7, align 8, !tbaa !5
  %2305 = getelementptr inbounds %struct.MDBX_cursor, ptr %2304, i32 0, i32 5
  %2306 = load ptr, ptr %2305, align 8, !tbaa !11
  %2307 = getelementptr inbounds %struct.MDBX_txn, ptr %2306, i32 0, i32 9
  %2308 = load ptr, ptr %2307, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %2308, ptr noundef @.str.76, ptr noundef @__func__.page_split, i32 noundef 1237) #11
  unreachable

2309:                                             ; preds = %2288
  br label %2310

2310:                                             ; preds = %2309
  br label %2311

2311:                                             ; preds = %2310
  br label %2312

2312:                                             ; preds = %2311, %2276
  br label %2313

2313:                                             ; preds = %2312
  br label %2314

2314:                                             ; preds = %2313
  br label %2315

2315:                                             ; preds = %2314
  %2316 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %2317 = zext i8 %2316 to i32
  %2318 = and i32 %2317, 1
  %2319 = icmp ne i32 %2318, 0
  %2320 = xor i1 %2319, true
  %2321 = xor i1 %2320, true
  %2322 = zext i1 %2321 to i32
  %2323 = sext i32 %2322 to i64
  %2324 = call i64 @llvm.expect.i64(i64 %2323, i64 1)
  %2325 = icmp ne i64 %2324, 0
  br i1 %2325, label %2326, label %2347

2326:                                             ; preds = %2315
  br label %2327

2327:                                             ; preds = %2326
  %2328 = load i8, ptr %39, align 1, !tbaa !44, !range !45, !noundef !46
  %2329 = trunc i8 %2328 to i1
  %2330 = xor i1 %2329, true
  %2331 = xor i1 %2330, true
  %2332 = xor i1 %2331, true
  %2333 = xor i1 %2332, true
  %2334 = zext i1 %2333 to i32
  %2335 = sext i32 %2334 to i64
  %2336 = call i64 @llvm.expect.i64(i64 %2335, i64 0)
  %2337 = icmp ne i64 %2336, 0
  br i1 %2337, label %2338, label %2344

2338:                                             ; preds = %2327
  %2339 = load ptr, ptr %7, align 8, !tbaa !5
  %2340 = getelementptr inbounds %struct.MDBX_cursor, ptr %2339, i32 0, i32 5
  %2341 = load ptr, ptr %2340, align 8, !tbaa !11
  %2342 = getelementptr inbounds %struct.MDBX_txn, ptr %2341, i32 0, i32 9
  %2343 = load ptr, ptr %2342, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %2343, ptr noundef @.str.77, ptr noundef @__func__.page_split, i32 noundef 1238) #11
  unreachable

2344:                                             ; preds = %2327
  br label %2345

2345:                                             ; preds = %2344
  br label %2346

2346:                                             ; preds = %2345
  br label %2347

2347:                                             ; preds = %2346, %2315
  br label %2348

2348:                                             ; preds = %2347
  br label %2349

2349:                                             ; preds = %2348
  call void @llvm.lifetime.start.p0(i64 4, ptr %63) #10
  %2350 = load ptr, ptr %7, align 8, !tbaa !5
  %2351 = getelementptr inbounds %struct.MDBX_cursor, ptr %2350, i32 0, i32 1
  %2352 = getelementptr inbounds %struct.anon.9, ptr %2351, i32 0, i32 1
  %2353 = load i8, ptr %2352, align 1, !tbaa !19
  %2354 = sext i8 %2353 to i32
  store i32 %2354, ptr %63, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %64) #10
  %2355 = load ptr, ptr %7, align 8, !tbaa !5
  %2356 = getelementptr inbounds %struct.MDBX_cursor, ptr %2355, i32 0, i32 6
  %2357 = load ptr, ptr %2356, align 8, !tbaa !32
  %2358 = getelementptr inbounds %struct.tree, ptr %2357, i32 0, i32 1
  %2359 = load i16, ptr %2358, align 2, !tbaa !33
  %2360 = zext i16 %2359 to i32
  store i32 %2360, ptr %64, align 4, !tbaa !9
  %2361 = load ptr, ptr %31, align 8, !tbaa !5
  %2362 = getelementptr inbounds %struct.MDBX_cursor, ptr %2361, i32 0, i32 1
  %2363 = getelementptr inbounds %struct.anon.9, ptr %2362, i32 0, i32 1
  %2364 = load i8, ptr %2363, align 1, !tbaa !19
  %2365 = sext i8 %2364 to i32
  %2366 = sub nsw i32 %2365, 1
  %2367 = trunc i32 %2366 to i8
  store i8 %2367, ptr %2363, align 1, !tbaa !19
  store i8 1, ptr %62, align 1, !tbaa !44
  %2368 = load ptr, ptr %31, align 8, !tbaa !5
  %2369 = getelementptr inbounds %struct.MDBX_cursor, ptr %2368, i32 0, i32 5
  %2370 = load ptr, ptr %2369, align 8, !tbaa !11
  %2371 = getelementptr inbounds %struct.MDBX_txn, ptr %2370, i32 0, i32 14
  %2372 = load ptr, ptr %2371, align 8, !tbaa !51
  %2373 = load ptr, ptr %31, align 8, !tbaa !5
  %2374 = call i64 @cursor_dbi(ptr noundef %2373) #12
  %2375 = getelementptr inbounds ptr, ptr %2372, i64 %2374
  %2376 = load ptr, ptr %2375, align 8, !tbaa !5
  %2377 = getelementptr inbounds %struct.cursor_couple, ptr %30, i32 0, i32 0
  %2378 = getelementptr inbounds %struct.MDBX_cursor, ptr %2377, i32 0, i32 11
  store ptr %2376, ptr %2378, align 8, !tbaa !52
  %2379 = getelementptr inbounds %struct.cursor_couple, ptr %30, i32 0, i32 0
  %2380 = load ptr, ptr %31, align 8, !tbaa !5
  %2381 = getelementptr inbounds %struct.MDBX_cursor, ptr %2380, i32 0, i32 5
  %2382 = load ptr, ptr %2381, align 8, !tbaa !11
  %2383 = getelementptr inbounds %struct.MDBX_txn, ptr %2382, i32 0, i32 14
  %2384 = load ptr, ptr %2383, align 8, !tbaa !51
  %2385 = load ptr, ptr %31, align 8, !tbaa !5
  %2386 = call i64 @cursor_dbi(ptr noundef %2385) #12
  %2387 = getelementptr inbounds ptr, ptr %2384, i64 %2386
  store ptr %2379, ptr %2387, align 8, !tbaa !5
  %2388 = load ptr, ptr %31, align 8, !tbaa !5
  %2389 = load ptr, ptr %26, align 8, !tbaa !5
  %2390 = getelementptr inbounds %struct.page, ptr %2389, i32 0, i32 4
  %2391 = load i32, ptr %2390, align 1, !tbaa !9
  %2392 = call i32 @page_split(ptr noundef %2388, ptr noundef %33, ptr noundef null, i32 noundef %2391, i32 noundef 0)
  store i32 %2392, ptr %13, align 4, !tbaa !9
  %2393 = getelementptr inbounds %struct.cursor_couple, ptr %30, i32 0, i32 0
  %2394 = getelementptr inbounds %struct.MDBX_cursor, ptr %2393, i32 0, i32 11
  %2395 = load ptr, ptr %2394, align 8, !tbaa !52
  %2396 = load ptr, ptr %31, align 8, !tbaa !5
  %2397 = getelementptr inbounds %struct.MDBX_cursor, ptr %2396, i32 0, i32 5
  %2398 = load ptr, ptr %2397, align 8, !tbaa !11
  %2399 = getelementptr inbounds %struct.MDBX_txn, ptr %2398, i32 0, i32 14
  %2400 = load ptr, ptr %2399, align 8, !tbaa !51
  %2401 = load ptr, ptr %31, align 8, !tbaa !5
  %2402 = call i64 @cursor_dbi(ptr noundef %2401) #12
  %2403 = getelementptr inbounds ptr, ptr %2400, i64 %2402
  store ptr %2395, ptr %2403, align 8, !tbaa !5
  %2404 = load i32, ptr %13, align 4, !tbaa !9
  %2405 = icmp ne i32 %2404, 0
  %2406 = xor i1 %2405, true
  %2407 = xor i1 %2406, true
  %2408 = zext i1 %2407 to i32
  %2409 = sext i32 %2408 to i64
  %2410 = call i64 @llvm.expect.i64(i64 %2409, i64 0)
  %2411 = icmp ne i64 %2410, 0
  br i1 %2411, label %2412, label %2413

2412:                                             ; preds = %2349
  store i32 14, ptr %23, align 4
  br label %2670

2413:                                             ; preds = %2349
  br label %2414

2414:                                             ; preds = %2413
  %2415 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %2416 = zext i8 %2415 to i32
  %2417 = and i32 %2416, 1
  %2418 = icmp ne i32 %2417, 0
  %2419 = xor i1 %2418, true
  %2420 = xor i1 %2419, true
  %2421 = zext i1 %2420 to i32
  %2422 = sext i32 %2421 to i64
  %2423 = call i64 @llvm.expect.i64(i64 %2422, i64 1)
  %2424 = icmp ne i64 %2423, 0
  br i1 %2424, label %2425, label %2459

2425:                                             ; preds = %2414
  br label %2426

2426:                                             ; preds = %2425
  %2427 = load ptr, ptr %7, align 8, !tbaa !5
  %2428 = getelementptr inbounds %struct.MDBX_cursor, ptr %2427, i32 0, i32 1
  %2429 = getelementptr inbounds %struct.anon.9, ptr %2428, i32 0, i32 1
  %2430 = load i8, ptr %2429, align 1, !tbaa !19
  %2431 = sext i8 %2430 to i32
  %2432 = load i32, ptr %63, align 4, !tbaa !9
  %2433 = sub nsw i32 %2431, %2432
  %2434 = load ptr, ptr %7, align 8, !tbaa !5
  %2435 = getelementptr inbounds %struct.MDBX_cursor, ptr %2434, i32 0, i32 6
  %2436 = load ptr, ptr %2435, align 8, !tbaa !32
  %2437 = getelementptr inbounds %struct.tree, ptr %2436, i32 0, i32 1
  %2438 = load i16, ptr %2437, align 2, !tbaa !33
  %2439 = zext i16 %2438 to i32
  %2440 = load i32, ptr %64, align 4, !tbaa !9
  %2441 = sub nsw i32 %2439, %2440
  %2442 = icmp eq i32 %2433, %2441
  %2443 = xor i1 %2442, true
  %2444 = xor i1 %2443, true
  %2445 = xor i1 %2444, true
  %2446 = zext i1 %2445 to i32
  %2447 = sext i32 %2446 to i64
  %2448 = call i64 @llvm.expect.i64(i64 %2447, i64 0)
  %2449 = icmp ne i64 %2448, 0
  br i1 %2449, label %2450, label %2456

2450:                                             ; preds = %2426
  %2451 = load ptr, ptr %7, align 8, !tbaa !5
  %2452 = getelementptr inbounds %struct.MDBX_cursor, ptr %2451, i32 0, i32 5
  %2453 = load ptr, ptr %2452, align 8, !tbaa !11
  %2454 = getelementptr inbounds %struct.MDBX_txn, ptr %2453, i32 0, i32 9
  %2455 = load ptr, ptr %2454, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %2455, ptr noundef @.str.78, ptr noundef @__func__.page_split, i32 noundef 1249) #11
  unreachable

2456:                                             ; preds = %2426
  br label %2457

2457:                                             ; preds = %2456
  br label %2458

2458:                                             ; preds = %2457
  br label %2459

2459:                                             ; preds = %2458, %2414
  br label %2460

2460:                                             ; preds = %2459
  br label %2461

2461:                                             ; preds = %2460
  %2462 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %2463 = zext i8 %2462 to i32
  %2464 = and i32 %2463, 2
  %2465 = icmp ne i32 %2464, 0
  %2466 = xor i1 %2465, true
  %2467 = xor i1 %2466, true
  %2468 = zext i1 %2467 to i32
  %2469 = sext i32 %2468 to i64
  %2470 = call i64 @llvm.expect.i64(i64 %2469, i64 0)
  %2471 = icmp ne i64 %2470, 0
  br i1 %2471, label %2472, label %2485

2472:                                             ; preds = %2461
  %2473 = load ptr, ptr %7, align 8, !tbaa !5
  %2474 = call i32 @cursor_validate_updating(ptr noundef %2473)
  store i32 %2474, ptr %13, align 4, !tbaa !9
  %2475 = load i32, ptr %13, align 4, !tbaa !9
  %2476 = icmp ne i32 %2475, 0
  %2477 = xor i1 %2476, true
  %2478 = xor i1 %2477, true
  %2479 = zext i1 %2478 to i32
  %2480 = sext i32 %2479 to i64
  %2481 = call i64 @llvm.expect.i64(i64 %2480, i64 0)
  %2482 = icmp ne i64 %2481, 0
  br i1 %2482, label %2483, label %2484

2483:                                             ; preds = %2472
  store i32 14, ptr %23, align 4
  br label %2670

2484:                                             ; preds = %2472
  br label %2485

2485:                                             ; preds = %2484, %2461
  %2486 = load ptr, ptr %7, align 8, !tbaa !5
  %2487 = getelementptr inbounds %struct.MDBX_cursor, ptr %2486, i32 0, i32 1
  %2488 = getelementptr inbounds %struct.anon.9, ptr %2487, i32 0, i32 1
  %2489 = load i8, ptr %2488, align 1, !tbaa !19
  %2490 = sext i8 %2489 to i32
  %2491 = load i32, ptr %63, align 4, !tbaa !9
  %2492 = sub nsw i32 %2490, %2491
  %2493 = sext i32 %2492 to i64
  %2494 = load i64, ptr %27, align 8, !tbaa !24
  %2495 = add nsw i64 %2494, %2493
  store i64 %2495, ptr %27, align 8, !tbaa !24
  br label %2496

2496:                                             ; preds = %2485
  %2497 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %2498 = zext i8 %2497 to i32
  %2499 = and i32 %2498, 1
  %2500 = icmp ne i32 %2499, 0
  %2501 = xor i1 %2500, true
  %2502 = xor i1 %2501, true
  %2503 = zext i1 %2502 to i32
  %2504 = sext i32 %2503 to i64
  %2505 = call i64 @llvm.expect.i64(i64 %2504, i64 1)
  %2506 = icmp ne i64 %2505, 0
  br i1 %2506, label %2507, label %2542

2507:                                             ; preds = %2496
  br label %2508

2508:                                             ; preds = %2507
  %2509 = load i64, ptr %27, align 8, !tbaa !24
  %2510 = load ptr, ptr %31, align 8, !tbaa !5
  %2511 = getelementptr inbounds %struct.MDBX_cursor, ptr %2510, i32 0, i32 1
  %2512 = getelementptr inbounds %struct.anon.9, ptr %2511, i32 0, i32 1
  %2513 = load i8, ptr %2512, align 1, !tbaa !19
  %2514 = sext i8 %2513 to i64
  %2515 = icmp sle i64 %2509, %2514
  br i1 %2515, label %2516, label %2524

2516:                                             ; preds = %2508
  %2517 = load i64, ptr %27, align 8, !tbaa !24
  %2518 = load ptr, ptr %7, align 8, !tbaa !5
  %2519 = getelementptr inbounds %struct.MDBX_cursor, ptr %2518, i32 0, i32 1
  %2520 = getelementptr inbounds %struct.anon.9, ptr %2519, i32 0, i32 1
  %2521 = load i8, ptr %2520, align 1, !tbaa !19
  %2522 = sext i8 %2521 to i64
  %2523 = icmp sle i64 %2517, %2522
  br label %2524

2524:                                             ; preds = %2516, %2508
  %2525 = phi i1 [ false, %2508 ], [ %2523, %2516 ]
  %2526 = xor i1 %2525, true
  %2527 = xor i1 %2526, true
  %2528 = xor i1 %2527, true
  %2529 = zext i1 %2528 to i32
  %2530 = sext i32 %2529 to i64
  %2531 = call i64 @llvm.expect.i64(i64 %2530, i64 0)
  %2532 = icmp ne i64 %2531, 0
  br i1 %2532, label %2533, label %2539

2533:                                             ; preds = %2524
  %2534 = load ptr, ptr %31, align 8, !tbaa !5
  %2535 = getelementptr inbounds %struct.MDBX_cursor, ptr %2534, i32 0, i32 5
  %2536 = load ptr, ptr %2535, align 8, !tbaa !11
  %2537 = getelementptr inbounds %struct.MDBX_txn, ptr %2536, i32 0, i32 9
  %2538 = load ptr, ptr %2537, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %2538, ptr noundef @.str.79, ptr noundef @__func__.page_split, i32 noundef 1258) #11
  unreachable

2539:                                             ; preds = %2524
  br label %2540

2540:                                             ; preds = %2539
  br label %2541

2541:                                             ; preds = %2540
  br label %2542

2542:                                             ; preds = %2541, %2496
  br label %2543

2543:                                             ; preds = %2542
  br label %2544

2544:                                             ; preds = %2543
  %2545 = load ptr, ptr %31, align 8, !tbaa !5
  %2546 = getelementptr inbounds %struct.MDBX_cursor, ptr %2545, i32 0, i32 9
  %2547 = load i64, ptr %27, align 8, !tbaa !24
  %2548 = getelementptr inbounds [32 x ptr], ptr %2546, i64 0, i64 %2547
  %2549 = load ptr, ptr %2548, align 8, !tbaa !5
  %2550 = load ptr, ptr %7, align 8, !tbaa !5
  %2551 = getelementptr inbounds %struct.MDBX_cursor, ptr %2550, i32 0, i32 9
  %2552 = load i64, ptr %27, align 8, !tbaa !24
  %2553 = getelementptr inbounds [32 x ptr], ptr %2551, i64 0, i64 %2552
  %2554 = load ptr, ptr %2553, align 8, !tbaa !5
  %2555 = icmp ne ptr %2549, %2554
  br i1 %2555, label %2556, label %2669

2556:                                             ; preds = %2544
  %2557 = load ptr, ptr %7, align 8, !tbaa !5
  %2558 = getelementptr inbounds %struct.MDBX_cursor, ptr %2557, i32 0, i32 10
  %2559 = load i64, ptr %27, align 8, !tbaa !24
  %2560 = getelementptr inbounds [32 x i16], ptr %2558, i64 0, i64 %2559
  %2561 = load i16, ptr %2560, align 2, !tbaa !23
  %2562 = zext i16 %2561 to i64
  %2563 = load ptr, ptr %7, align 8, !tbaa !5
  %2564 = getelementptr inbounds %struct.MDBX_cursor, ptr %2563, i32 0, i32 9
  %2565 = load i64, ptr %27, align 8, !tbaa !24
  %2566 = getelementptr inbounds [32 x ptr], ptr %2564, i64 0, i64 %2565
  %2567 = load ptr, ptr %2566, align 8, !tbaa !5
  %2568 = call i64 @page_numkeys(ptr noundef %2567) #12
  %2569 = icmp uge i64 %2562, %2568
  br i1 %2569, label %2570, label %2669

2570:                                             ; preds = %2556
  call void @llvm.lifetime.start.p0(i64 8, ptr %65) #10
  store i64 0, ptr %65, align 8, !tbaa !24
  br label %2571

2571:                                             ; preds = %2595, %2570
  %2572 = load i64, ptr %65, align 8, !tbaa !24
  %2573 = load i64, ptr %27, align 8, !tbaa !24
  %2574 = icmp slt i64 %2572, %2573
  br i1 %2574, label %2576, label %2575

2575:                                             ; preds = %2571
  store i32 148, ptr %23, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %65) #10
  br label %2598

2576:                                             ; preds = %2571
  %2577 = load ptr, ptr %31, align 8, !tbaa !5
  %2578 = getelementptr inbounds %struct.MDBX_cursor, ptr %2577, i32 0, i32 9
  %2579 = load i64, ptr %65, align 8, !tbaa !24
  %2580 = getelementptr inbounds [32 x ptr], ptr %2578, i64 0, i64 %2579
  %2581 = load ptr, ptr %2580, align 8, !tbaa !5
  %2582 = load ptr, ptr %7, align 8, !tbaa !5
  %2583 = getelementptr inbounds %struct.MDBX_cursor, ptr %2582, i32 0, i32 9
  %2584 = load i64, ptr %65, align 8, !tbaa !24
  %2585 = getelementptr inbounds [32 x ptr], ptr %2583, i64 0, i64 %2584
  store ptr %2581, ptr %2585, align 8, !tbaa !5
  %2586 = load ptr, ptr %31, align 8, !tbaa !5
  %2587 = getelementptr inbounds %struct.MDBX_cursor, ptr %2586, i32 0, i32 10
  %2588 = load i64, ptr %65, align 8, !tbaa !24
  %2589 = getelementptr inbounds [32 x i16], ptr %2587, i64 0, i64 %2588
  %2590 = load i16, ptr %2589, align 2, !tbaa !23
  %2591 = load ptr, ptr %7, align 8, !tbaa !5
  %2592 = getelementptr inbounds %struct.MDBX_cursor, ptr %2591, i32 0, i32 10
  %2593 = load i64, ptr %65, align 8, !tbaa !24
  %2594 = getelementptr inbounds [32 x i16], ptr %2592, i64 0, i64 %2593
  store i16 %2590, ptr %2594, align 2, !tbaa !23
  br label %2595

2595:                                             ; preds = %2576
  %2596 = load i64, ptr %65, align 8, !tbaa !24
  %2597 = add nsw i64 %2596, 1
  store i64 %2597, ptr %65, align 8, !tbaa !24
  br label %2571, !llvm.loop !55

2598:                                             ; preds = %2575
  %2599 = load ptr, ptr %31, align 8, !tbaa !5
  %2600 = getelementptr inbounds %struct.MDBX_cursor, ptr %2599, i32 0, i32 9
  %2601 = load i64, ptr %27, align 8, !tbaa !24
  %2602 = getelementptr inbounds [32 x ptr], ptr %2600, i64 0, i64 %2601
  %2603 = load ptr, ptr %2602, align 8, !tbaa !5
  %2604 = load ptr, ptr %7, align 8, !tbaa !5
  %2605 = getelementptr inbounds %struct.MDBX_cursor, ptr %2604, i32 0, i32 9
  %2606 = load i64, ptr %27, align 8, !tbaa !24
  %2607 = getelementptr inbounds [32 x ptr], ptr %2605, i64 0, i64 %2606
  store ptr %2603, ptr %2607, align 8, !tbaa !5
  %2608 = load ptr, ptr %31, align 8, !tbaa !5
  %2609 = getelementptr inbounds %struct.MDBX_cursor, ptr %2608, i32 0, i32 10
  %2610 = load i64, ptr %27, align 8, !tbaa !24
  %2611 = getelementptr inbounds [32 x i16], ptr %2609, i64 0, i64 %2610
  %2612 = load i16, ptr %2611, align 2, !tbaa !23
  %2613 = icmp ne i16 %2612, 0
  br i1 %2613, label %2614, label %2627

2614:                                             ; preds = %2598
  %2615 = load ptr, ptr %31, align 8, !tbaa !5
  %2616 = getelementptr inbounds %struct.MDBX_cursor, ptr %2615, i32 0, i32 10
  %2617 = load i64, ptr %27, align 8, !tbaa !24
  %2618 = getelementptr inbounds [32 x i16], ptr %2616, i64 0, i64 %2617
  %2619 = load i16, ptr %2618, align 2, !tbaa !23
  %2620 = zext i16 %2619 to i32
  %2621 = sub nsw i32 %2620, 1
  %2622 = trunc i32 %2621 to i16
  %2623 = load ptr, ptr %7, align 8, !tbaa !5
  %2624 = getelementptr inbounds %struct.MDBX_cursor, ptr %2623, i32 0, i32 10
  %2625 = load i64, ptr %27, align 8, !tbaa !24
  %2626 = getelementptr inbounds [32 x i16], ptr %2624, i64 0, i64 %2625
  store i16 %2622, ptr %2626, align 2, !tbaa !23
  br label %2668

2627:                                             ; preds = %2598
  %2628 = load ptr, ptr %31, align 8, !tbaa !5
  %2629 = getelementptr inbounds %struct.MDBX_cursor, ptr %2628, i32 0, i32 10
  %2630 = load i64, ptr %27, align 8, !tbaa !24
  %2631 = getelementptr inbounds [32 x i16], ptr %2629, i64 0, i64 %2630
  %2632 = load i16, ptr %2631, align 2, !tbaa !23
  %2633 = load ptr, ptr %7, align 8, !tbaa !5
  %2634 = getelementptr inbounds %struct.MDBX_cursor, ptr %2633, i32 0, i32 10
  %2635 = load i64, ptr %27, align 8, !tbaa !24
  %2636 = getelementptr inbounds [32 x i16], ptr %2634, i64 0, i64 %2635
  store i16 %2632, ptr %2636, align 2, !tbaa !23
  %2637 = load ptr, ptr %7, align 8, !tbaa !5
  %2638 = call i32 @cursor_sibling_left(ptr noundef %2637)
  store i32 %2638, ptr %13, align 4, !tbaa !9
  %2639 = load i32, ptr %13, align 4, !tbaa !9
  %2640 = icmp ne i32 %2639, 0
  %2641 = xor i1 %2640, true
  %2642 = xor i1 %2641, true
  %2643 = zext i1 %2642 to i32
  %2644 = sext i32 %2643 to i64
  %2645 = call i64 @llvm.expect.i64(i64 %2644, i64 0)
  %2646 = icmp ne i64 %2645, 0
  br i1 %2646, label %2647, label %2667

2647:                                             ; preds = %2627
  %2648 = load i32, ptr %13, align 4, !tbaa !9
  %2649 = icmp eq i32 %2648, -30798
  br i1 %2649, label %2650, label %2666

2650:                                             ; preds = %2647
  br label %2651

2651:                                             ; preds = %2650
  %2652 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 5), align 2, !tbaa !25
  %2653 = zext i8 %2652 to i32
  %2654 = icmp sle i32 1, %2653
  %2655 = xor i1 %2654, true
  %2656 = xor i1 %2655, true
  %2657 = zext i1 %2656 to i32
  %2658 = sext i32 %2657 to i64
  %2659 = call i64 @llvm.expect.i64(i64 %2658, i64 0)
  %2660 = icmp ne i64 %2659, 0
  br i1 %2660, label %2661, label %2663

2661:                                             ; preds = %2651
  %2662 = load i32, ptr %13, align 4, !tbaa !9
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 1, ptr noundef @__func__.page_split, i32 noundef 1276, ptr noundef @.str.80, i32 noundef %2662)
  br label %2663

2663:                                             ; preds = %2661, %2651
  br label %2664

2664:                                             ; preds = %2663
  br label %2665

2665:                                             ; preds = %2664
  store i32 -30779, ptr %13, align 4, !tbaa !9
  br label %2666

2666:                                             ; preds = %2665, %2647
  store i32 14, ptr %23, align 4
  br label %2670

2667:                                             ; preds = %2627
  br label %2668

2668:                                             ; preds = %2667, %2614
  br label %2669

2669:                                             ; preds = %2668, %2556, %2544
  store i32 0, ptr %23, align 4
  br label %2670

2670:                                             ; preds = %2669, %2666, %2483, %2412
  call void @llvm.lifetime.end.p0(i64 4, ptr %64) #10
  call void @llvm.lifetime.end.p0(i64 4, ptr %63) #10
  %2671 = load i32, ptr %23, align 4
  switch i32 %2671, label %4629 [
    i32 0, label %2672
    i32 14, label %4523
  ]

2672:                                             ; preds = %2670
  br label %3248

2673:                                             ; preds = %2249
  %2674 = load i8, ptr %39, align 1, !tbaa !44, !range !45, !noundef !46
  %2675 = trunc i8 %2674 to i1
  %2676 = xor i1 %2675, true
  %2677 = xor i1 %2676, true
  %2678 = zext i1 %2677 to i32
  %2679 = sext i32 %2678 to i64
  %2680 = call i64 @llvm.expect.i64(i64 %2679, i64 0)
  %2681 = icmp ne i64 %2680, 0
  br i1 %2681, label %2682, label %3191

2682:                                             ; preds = %2673
  call void @llvm.lifetime.start.p0(i64 8, ptr %66) #10
  %2683 = load ptr, ptr %7, align 8, !tbaa !5
  %2684 = getelementptr inbounds %struct.MDBX_cursor, ptr %2683, i32 0, i32 9
  %2685 = load i64, ptr %27, align 8, !tbaa !24
  %2686 = getelementptr inbounds [32 x ptr], ptr %2684, i64 0, i64 %2685
  %2687 = load ptr, ptr %2686, align 8, !tbaa !5
  store ptr %2687, ptr %66, align 8, !tbaa !5
  br label %2688

2688:                                             ; preds = %2682
  %2689 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 5), align 2, !tbaa !25
  %2690 = zext i8 %2689 to i32
  %2691 = icmp sle i32 6, %2690
  %2692 = xor i1 %2691, true
  %2693 = xor i1 %2692, true
  %2694 = zext i1 %2693 to i32
  %2695 = sext i32 %2694 to i64
  %2696 = call i64 @llvm.expect.i64(i64 %2695, i64 0)
  %2697 = icmp ne i64 %2696, 0
  br i1 %2697, label %2698, label %2725

2698:                                             ; preds = %2688
  %2699 = load ptr, ptr %66, align 8, !tbaa !5
  %2700 = getelementptr inbounds %struct.page, ptr %2699, i32 0, i32 4
  %2701 = load i32, ptr %2700, align 1, !tbaa !9
  %2702 = load ptr, ptr %7, align 8, !tbaa !5
  %2703 = getelementptr inbounds %struct.MDBX_cursor, ptr %2702, i32 0, i32 10
  %2704 = load i64, ptr %27, align 8, !tbaa !24
  %2705 = getelementptr inbounds [32 x i16], ptr %2703, i64 0, i64 %2704
  %2706 = load i16, ptr %2705, align 2, !tbaa !23
  %2707 = zext i16 %2706 to i32
  %2708 = load ptr, ptr %26, align 8, !tbaa !5
  %2709 = getelementptr inbounds %struct.page, ptr %2708, i32 0, i32 4
  %2710 = load i32, ptr %2709, align 1, !tbaa !9
  %2711 = load ptr, ptr %7, align 8, !tbaa !5
  %2712 = getelementptr inbounds %struct.MDBX_cursor, ptr %2711, i32 0, i32 10
  %2713 = load i64, ptr %27, align 8, !tbaa !24
  %2714 = getelementptr inbounds [32 x i16], ptr %2712, i64 0, i64 %2713
  %2715 = load i16, ptr %2714, align 2, !tbaa !23
  %2716 = zext i16 %2715 to i32
  %2717 = icmp ne i32 %2716, 0
  br i1 %2717, label %2718, label %2720

2718:                                             ; preds = %2698
  %2719 = load ptr, ptr %8, align 8, !tbaa !5
  br label %2721

2720:                                             ; preds = %2698
  br label %2721

2721:                                             ; preds = %2720, %2718
  %2722 = phi ptr [ %2719, %2718 ], [ null, %2720 ]
  %2723 = getelementptr inbounds [510 x i8], ptr %19, i64 0, i64 0
  %2724 = call ptr @mdbx_dump_val(ptr noundef %2722, ptr noundef %2723, i64 noundef 255)
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef @__func__.page_split, i32 noundef 1287, ptr noundef @.str.81, i32 noundef %2701, i32 noundef %2707, i32 noundef %2710, ptr noundef %2724)
  br label %2725

2725:                                             ; preds = %2721, %2688
  br label %2726

2726:                                             ; preds = %2725
  br label %2727

2727:                                             ; preds = %2726
  br label %2728

2728:                                             ; preds = %2727
  %2729 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %2730 = zext i8 %2729 to i32
  %2731 = and i32 %2730, 1
  %2732 = icmp ne i32 %2731, 0
  %2733 = xor i1 %2732, true
  %2734 = xor i1 %2733, true
  %2735 = zext i1 %2734 to i32
  %2736 = sext i32 %2735 to i64
  %2737 = call i64 @llvm.expect.i64(i64 %2736, i64 1)
  %2738 = icmp ne i64 %2737, 0
  br i1 %2738, label %2739, label %2760

2739:                                             ; preds = %2728
  br label %2740

2740:                                             ; preds = %2739
  %2741 = load ptr, ptr %7, align 8, !tbaa !5
  %2742 = getelementptr inbounds %struct.MDBX_cursor, ptr %2741, i32 0, i32 1
  %2743 = getelementptr inbounds %struct.anon.9, ptr %2742, i32 0, i32 1
  %2744 = load i8, ptr %2743, align 1, !tbaa !19
  %2745 = sext i8 %2744 to i64
  %2746 = load i64, ptr %27, align 8, !tbaa !24
  %2747 = add nsw i64 %2746, 1
  %2748 = icmp eq i64 %2745, %2747
  %2749 = xor i1 %2748, true
  %2750 = xor i1 %2749, true
  %2751 = xor i1 %2750, true
  %2752 = zext i1 %2751 to i32
  %2753 = sext i32 %2752 to i64
  %2754 = call i64 @llvm.expect.i64(i64 %2753, i64 0)
  %2755 = icmp ne i64 %2754, 0
  br i1 %2755, label %2756, label %2757

2756:                                             ; preds = %2740
  call void @mdbx_assert_fail(ptr noundef null, ptr noundef @.str.82, ptr noundef @__func__.page_split, i32 noundef 1288) #11
  unreachable

2757:                                             ; preds = %2740
  br label %2758

2758:                                             ; preds = %2757
  br label %2759

2759:                                             ; preds = %2758
  br label %2760

2760:                                             ; preds = %2759, %2728
  br label %2761

2761:                                             ; preds = %2760
  br label %2762

2762:                                             ; preds = %2761
  %2763 = load i64, ptr %27, align 8, !tbaa !24
  %2764 = trunc i64 %2763 to i8
  %2765 = load ptr, ptr %7, align 8, !tbaa !5
  %2766 = getelementptr inbounds %struct.MDBX_cursor, ptr %2765, i32 0, i32 1
  %2767 = getelementptr inbounds %struct.anon.9, ptr %2766, i32 0, i32 1
  store i8 %2764, ptr %2767, align 1, !tbaa !19
  %2768 = load ptr, ptr %7, align 8, !tbaa !5
  %2769 = load ptr, ptr %7, align 8, !tbaa !5
  %2770 = getelementptr inbounds %struct.MDBX_cursor, ptr %2769, i32 0, i32 10
  %2771 = load i64, ptr %27, align 8, !tbaa !24
  %2772 = getelementptr inbounds [32 x i16], ptr %2770, i64 0, i64 %2771
  %2773 = load i16, ptr %2772, align 2, !tbaa !23
  %2774 = zext i16 %2773 to i64
  %2775 = load ptr, ptr %7, align 8, !tbaa !5
  %2776 = getelementptr inbounds %struct.MDBX_cursor, ptr %2775, i32 0, i32 10
  %2777 = load i64, ptr %27, align 8, !tbaa !24
  %2778 = getelementptr inbounds [32 x i16], ptr %2776, i64 0, i64 %2777
  %2779 = load i16, ptr %2778, align 2, !tbaa !23
  %2780 = zext i16 %2779 to i32
  %2781 = icmp ne i32 %2780, 0
  br i1 %2781, label %2782, label %2784

2782:                                             ; preds = %2762
  %2783 = load ptr, ptr %8, align 8, !tbaa !5
  br label %2785

2784:                                             ; preds = %2762
  br label %2785

2785:                                             ; preds = %2784, %2782
  %2786 = phi ptr [ %2783, %2782 ], [ null, %2784 ]
  %2787 = load ptr, ptr %26, align 8, !tbaa !5
  %2788 = getelementptr inbounds %struct.page, ptr %2787, i32 0, i32 4
  %2789 = load i32, ptr %2788, align 1, !tbaa !9
  %2790 = call i32 @node_add_branch(ptr noundef %2768, i64 noundef %2774, ptr noundef %2786, i32 noundef %2789)
  store i32 %2790, ptr %13, align 4, !tbaa !9
  br label %2791

2791:                                             ; preds = %2785
  %2792 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %2793 = zext i8 %2792 to i32
  %2794 = and i32 %2793, 1
  %2795 = icmp ne i32 %2794, 0
  %2796 = xor i1 %2795, true
  %2797 = xor i1 %2796, true
  %2798 = zext i1 %2797 to i32
  %2799 = sext i32 %2798 to i64
  %2800 = call i64 @llvm.expect.i64(i64 %2799, i64 1)
  %2801 = icmp ne i64 %2800, 0
  br i1 %2801, label %2802, label %2848

2802:                                             ; preds = %2791
  br label %2803

2803:                                             ; preds = %2802
  %2804 = load ptr, ptr %20, align 8, !tbaa !5
  %2805 = load ptr, ptr %7, align 8, !tbaa !5
  %2806 = getelementptr inbounds %struct.MDBX_cursor, ptr %2805, i32 0, i32 9
  %2807 = load i64, ptr %27, align 8, !tbaa !24
  %2808 = add nsw i64 %2807, 1
  %2809 = getelementptr inbounds [32 x ptr], ptr %2806, i64 0, i64 %2808
  %2810 = load ptr, ptr %2809, align 8, !tbaa !5
  %2811 = icmp eq ptr %2804, %2810
  br i1 %2811, label %2812, label %2830

2812:                                             ; preds = %2803
  %2813 = load i64, ptr %21, align 8, !tbaa !24
  %2814 = load ptr, ptr %7, align 8, !tbaa !5
  %2815 = getelementptr inbounds %struct.MDBX_cursor, ptr %2814, i32 0, i32 10
  %2816 = load i64, ptr %27, align 8, !tbaa !24
  %2817 = add nsw i64 %2816, 1
  %2818 = getelementptr inbounds [32 x i16], ptr %2815, i64 0, i64 %2817
  %2819 = load i16, ptr %2818, align 2, !tbaa !23
  %2820 = zext i16 %2819 to i64
  %2821 = icmp eq i64 %2813, %2820
  br i1 %2821, label %2822, label %2830

2822:                                             ; preds = %2812
  %2823 = load i64, ptr %27, align 8, !tbaa !24
  %2824 = load ptr, ptr %7, align 8, !tbaa !5
  %2825 = getelementptr inbounds %struct.MDBX_cursor, ptr %2824, i32 0, i32 1
  %2826 = getelementptr inbounds %struct.anon.9, ptr %2825, i32 0, i32 1
  %2827 = load i8, ptr %2826, align 1, !tbaa !19
  %2828 = sext i8 %2827 to i64
  %2829 = icmp eq i64 %2823, %2828
  br label %2830

2830:                                             ; preds = %2822, %2812, %2803
  %2831 = phi i1 [ false, %2812 ], [ false, %2803 ], [ %2829, %2822 ]
  %2832 = xor i1 %2831, true
  %2833 = xor i1 %2832, true
  %2834 = xor i1 %2833, true
  %2835 = zext i1 %2834 to i32
  %2836 = sext i32 %2835 to i64
  %2837 = call i64 @llvm.expect.i64(i64 %2836, i64 0)
  %2838 = icmp ne i64 %2837, 0
  br i1 %2838, label %2839, label %2845

2839:                                             ; preds = %2830
  %2840 = load ptr, ptr %7, align 8, !tbaa !5
  %2841 = getelementptr inbounds %struct.MDBX_cursor, ptr %2840, i32 0, i32 5
  %2842 = load ptr, ptr %2841, align 8, !tbaa !11
  %2843 = getelementptr inbounds %struct.MDBX_txn, ptr %2842, i32 0, i32 9
  %2844 = load ptr, ptr %2843, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %2844, ptr noundef @.str.83, ptr noundef @__func__.page_split, i32 noundef 1291) #11
  unreachable

2845:                                             ; preds = %2830
  br label %2846

2846:                                             ; preds = %2845
  br label %2847

2847:                                             ; preds = %2846
  br label %2848

2848:                                             ; preds = %2847, %2791
  br label %2849

2849:                                             ; preds = %2848
  br label %2850

2850:                                             ; preds = %2849
  %2851 = load i32, ptr %13, align 4, !tbaa !9
  %2852 = icmp eq i32 %2851, 0
  %2853 = xor i1 %2852, true
  %2854 = xor i1 %2853, true
  %2855 = zext i1 %2854 to i32
  %2856 = sext i32 %2855 to i64
  %2857 = call i64 @llvm.expect.i64(i64 %2856, i64 1)
  %2858 = icmp ne i64 %2857, 0
  br i1 %2858, label %2859, label %3094

2859:                                             ; preds = %2850
  %2860 = load ptr, ptr %7, align 8, !tbaa !5
  %2861 = getelementptr inbounds %struct.MDBX_cursor, ptr %2860, i32 0, i32 10
  %2862 = load i64, ptr %27, align 8, !tbaa !24
  %2863 = getelementptr inbounds [32 x i16], ptr %2861, i64 0, i64 %2862
  %2864 = load i16, ptr %2863, align 2, !tbaa !23
  %2865 = zext i16 %2864 to i32
  %2866 = icmp eq i32 %2865, 0
  br i1 %2866, label %2867, label %3094

2867:                                             ; preds = %2859
  call void @llvm.lifetime.start.p0(i64 8, ptr %67) #10
  %2868 = load ptr, ptr %7, align 8, !tbaa !5
  %2869 = getelementptr inbounds %struct.MDBX_cursor, ptr %2868, i32 0, i32 9
  %2870 = load i64, ptr %27, align 8, !tbaa !24
  %2871 = getelementptr inbounds [32 x ptr], ptr %2869, i64 0, i64 %2870
  %2872 = load ptr, ptr %2871, align 8, !tbaa !5
  %2873 = call ptr @page_node(ptr noundef %2872, i64 noundef 1) #12
  store ptr %2873, ptr %67, align 8, !tbaa !5
  br label %2874

2874:                                             ; preds = %2867
  %2875 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 5), align 2, !tbaa !25
  %2876 = zext i8 %2875 to i32
  %2877 = icmp sle i32 6, %2876
  %2878 = xor i1 %2877, true
  %2879 = xor i1 %2878, true
  %2880 = zext i1 %2879 to i32
  %2881 = sext i32 %2880 to i64
  %2882 = call i64 @llvm.expect.i64(i64 %2881, i64 0)
  %2883 = icmp ne i64 %2882, 0
  br i1 %2883, label %2884, label %2887

2884:                                             ; preds = %2874
  %2885 = getelementptr inbounds [510 x i8], ptr %19, i64 0, i64 0
  %2886 = call ptr @mdbx_dump_val(ptr noundef %33, ptr noundef %2885, i64 noundef 255)
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef @__func__.page_split, i32 noundef 1295, ptr noundef @.str.84, ptr noundef %2886)
  br label %2887

2887:                                             ; preds = %2884, %2874
  br label %2888

2888:                                             ; preds = %2887
  br label %2889

2889:                                             ; preds = %2888
  br label %2890

2890:                                             ; preds = %2889
  %2891 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %2892 = zext i8 %2891 to i32
  %2893 = and i32 %2892, 1
  %2894 = icmp ne i32 %2893, 0
  %2895 = xor i1 %2894, true
  %2896 = xor i1 %2895, true
  %2897 = zext i1 %2896 to i32
  %2898 = sext i32 %2897 to i64
  %2899 = call i64 @llvm.expect.i64(i64 %2898, i64 1)
  %2900 = icmp ne i64 %2899, 0
  br i1 %2900, label %2901, label %2931

2901:                                             ; preds = %2890
  br label %2902

2902:                                             ; preds = %2901
  %2903 = load ptr, ptr %67, align 8, !tbaa !5
  %2904 = call i64 @node_ks(ptr noundef %2903) #12
  %2905 = icmp eq i64 %2904, 0
  br i1 %2905, label %2906, label %2913

2906:                                             ; preds = %2902
  %2907 = load ptr, ptr %67, align 8, !tbaa !5
  %2908 = call i32 @node_pgno(ptr noundef %2907) #12
  %2909 = load ptr, ptr %20, align 8, !tbaa !5
  %2910 = getelementptr inbounds %struct.page, ptr %2909, i32 0, i32 4
  %2911 = load i32, ptr %2910, align 1, !tbaa !9
  %2912 = icmp eq i32 %2908, %2911
  br label %2913

2913:                                             ; preds = %2906, %2902
  %2914 = phi i1 [ false, %2902 ], [ %2912, %2906 ]
  %2915 = xor i1 %2914, true
  %2916 = xor i1 %2915, true
  %2917 = xor i1 %2916, true
  %2918 = zext i1 %2917 to i32
  %2919 = sext i32 %2918 to i64
  %2920 = call i64 @llvm.expect.i64(i64 %2919, i64 0)
  %2921 = icmp ne i64 %2920, 0
  br i1 %2921, label %2922, label %2928

2922:                                             ; preds = %2913
  %2923 = load ptr, ptr %7, align 8, !tbaa !5
  %2924 = getelementptr inbounds %struct.MDBX_cursor, ptr %2923, i32 0, i32 5
  %2925 = load ptr, ptr %2924, align 8, !tbaa !11
  %2926 = getelementptr inbounds %struct.MDBX_txn, ptr %2925, i32 0, i32 9
  %2927 = load ptr, ptr %2926, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %2927, ptr noundef @.str.85, ptr noundef @__func__.page_split, i32 noundef 1296) #11
  unreachable

2928:                                             ; preds = %2913
  br label %2929

2929:                                             ; preds = %2928
  br label %2930

2930:                                             ; preds = %2929
  br label %2931

2931:                                             ; preds = %2930, %2890
  br label %2932

2932:                                             ; preds = %2931
  br label %2933

2933:                                             ; preds = %2932
  br label %2934

2934:                                             ; preds = %2933
  %2935 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %2936 = zext i8 %2935 to i32
  %2937 = and i32 %2936, 1
  %2938 = icmp ne i32 %2937, 0
  %2939 = xor i1 %2938, true
  %2940 = xor i1 %2939, true
  %2941 = zext i1 %2940 to i32
  %2942 = sext i32 %2941 to i64
  %2943 = call i64 @llvm.expect.i64(i64 %2942, i64 1)
  %2944 = icmp ne i64 %2943, 0
  br i1 %2944, label %2945, label %2980

2945:                                             ; preds = %2934
  br label %2946

2946:                                             ; preds = %2945
  %2947 = load ptr, ptr %7, align 8, !tbaa !5
  %2948 = getelementptr inbounds %struct.MDBX_cursor, ptr %2947, i32 0, i32 1
  %2949 = getelementptr inbounds %struct.anon.9, ptr %2948, i32 0, i32 1
  %2950 = load i8, ptr %2949, align 1, !tbaa !19
  %2951 = sext i8 %2950 to i64
  %2952 = load i64, ptr %27, align 8, !tbaa !24
  %2953 = icmp eq i64 %2951, %2952
  br i1 %2953, label %2954, label %2962

2954:                                             ; preds = %2946
  %2955 = load ptr, ptr %7, align 8, !tbaa !5
  %2956 = getelementptr inbounds %struct.MDBX_cursor, ptr %2955, i32 0, i32 10
  %2957 = load i64, ptr %27, align 8, !tbaa !24
  %2958 = getelementptr inbounds [32 x i16], ptr %2956, i64 0, i64 %2957
  %2959 = load i16, ptr %2958, align 2, !tbaa !23
  %2960 = zext i16 %2959 to i32
  %2961 = icmp eq i32 %2960, 0
  br label %2962

2962:                                             ; preds = %2954, %2946
  %2963 = phi i1 [ false, %2946 ], [ %2961, %2954 ]
  %2964 = xor i1 %2963, true
  %2965 = xor i1 %2964, true
  %2966 = xor i1 %2965, true
  %2967 = zext i1 %2966 to i32
  %2968 = sext i32 %2967 to i64
  %2969 = call i64 @llvm.expect.i64(i64 %2968, i64 0)
  %2970 = icmp ne i64 %2969, 0
  br i1 %2970, label %2971, label %2977

2971:                                             ; preds = %2962
  %2972 = load ptr, ptr %7, align 8, !tbaa !5
  %2973 = getelementptr inbounds %struct.MDBX_cursor, ptr %2972, i32 0, i32 5
  %2974 = load ptr, ptr %2973, align 8, !tbaa !11
  %2975 = getelementptr inbounds %struct.MDBX_txn, ptr %2974, i32 0, i32 9
  %2976 = load ptr, ptr %2975, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %2976, ptr noundef @.str.86, ptr noundef @__func__.page_split, i32 noundef 1297) #11
  unreachable

2977:                                             ; preds = %2962
  br label %2978

2978:                                             ; preds = %2977
  br label %2979

2979:                                             ; preds = %2978
  br label %2980

2980:                                             ; preds = %2979, %2934
  br label %2981

2981:                                             ; preds = %2980
  br label %2982

2982:                                             ; preds = %2981
  %2983 = load ptr, ptr %7, align 8, !tbaa !5
  %2984 = getelementptr inbounds %struct.MDBX_cursor, ptr %2983, i32 0, i32 10
  %2985 = load i64, ptr %27, align 8, !tbaa !24
  %2986 = getelementptr inbounds [32 x i16], ptr %2984, i64 0, i64 %2985
  store i16 1, ptr %2986, align 2, !tbaa !23
  %2987 = load ptr, ptr %7, align 8, !tbaa !5
  %2988 = call i32 @tree_propagate_key(ptr noundef %2987, ptr noundef %33)
  store i32 %2988, ptr %13, align 4, !tbaa !9
  br label %2989

2989:                                             ; preds = %2982
  %2990 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %2991 = zext i8 %2990 to i32
  %2992 = and i32 %2991, 1
  %2993 = icmp ne i32 %2992, 0
  %2994 = xor i1 %2993, true
  %2995 = xor i1 %2994, true
  %2996 = zext i1 %2995 to i32
  %2997 = sext i32 %2996 to i64
  %2998 = call i64 @llvm.expect.i64(i64 %2997, i64 1)
  %2999 = icmp ne i64 %2998, 0
  br i1 %2999, label %3000, label %3035

3000:                                             ; preds = %2989
  br label %3001

3001:                                             ; preds = %3000
  %3002 = load ptr, ptr %7, align 8, !tbaa !5
  %3003 = getelementptr inbounds %struct.MDBX_cursor, ptr %3002, i32 0, i32 1
  %3004 = getelementptr inbounds %struct.anon.9, ptr %3003, i32 0, i32 1
  %3005 = load i8, ptr %3004, align 1, !tbaa !19
  %3006 = sext i8 %3005 to i64
  %3007 = load i64, ptr %27, align 8, !tbaa !24
  %3008 = icmp eq i64 %3006, %3007
  br i1 %3008, label %3009, label %3017

3009:                                             ; preds = %3001
  %3010 = load ptr, ptr %7, align 8, !tbaa !5
  %3011 = getelementptr inbounds %struct.MDBX_cursor, ptr %3010, i32 0, i32 10
  %3012 = load i64, ptr %27, align 8, !tbaa !24
  %3013 = getelementptr inbounds [32 x i16], ptr %3011, i64 0, i64 %3012
  %3014 = load i16, ptr %3013, align 2, !tbaa !23
  %3015 = zext i16 %3014 to i32
  %3016 = icmp eq i32 %3015, 1
  br label %3017

3017:                                             ; preds = %3009, %3001
  %3018 = phi i1 [ false, %3001 ], [ %3016, %3009 ]
  %3019 = xor i1 %3018, true
  %3020 = xor i1 %3019, true
  %3021 = xor i1 %3020, true
  %3022 = zext i1 %3021 to i32
  %3023 = sext i32 %3022 to i64
  %3024 = call i64 @llvm.expect.i64(i64 %3023, i64 0)
  %3025 = icmp ne i64 %3024, 0
  br i1 %3025, label %3026, label %3032

3026:                                             ; preds = %3017
  %3027 = load ptr, ptr %7, align 8, !tbaa !5
  %3028 = getelementptr inbounds %struct.MDBX_cursor, ptr %3027, i32 0, i32 5
  %3029 = load ptr, ptr %3028, align 8, !tbaa !11
  %3030 = getelementptr inbounds %struct.MDBX_txn, ptr %3029, i32 0, i32 9
  %3031 = load ptr, ptr %3030, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %3031, ptr noundef @.str.87, ptr noundef @__func__.page_split, i32 noundef 1300) #11
  unreachable

3032:                                             ; preds = %3017
  br label %3033

3033:                                             ; preds = %3032
  br label %3034

3034:                                             ; preds = %3033
  br label %3035

3035:                                             ; preds = %3034, %2989
  br label %3036

3036:                                             ; preds = %3035
  br label %3037

3037:                                             ; preds = %3036
  br label %3038

3038:                                             ; preds = %3037
  %3039 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %3040 = zext i8 %3039 to i32
  %3041 = and i32 %3040, 1
  %3042 = icmp ne i32 %3041, 0
  %3043 = xor i1 %3042, true
  %3044 = xor i1 %3043, true
  %3045 = zext i1 %3044 to i32
  %3046 = sext i32 %3045 to i64
  %3047 = call i64 @llvm.expect.i64(i64 %3046, i64 1)
  %3048 = icmp ne i64 %3047, 0
  br i1 %3048, label %3049, label %3087

3049:                                             ; preds = %3038
  br label %3050

3050:                                             ; preds = %3049
  %3051 = load ptr, ptr %20, align 8, !tbaa !5
  %3052 = load ptr, ptr %7, align 8, !tbaa !5
  %3053 = getelementptr inbounds %struct.MDBX_cursor, ptr %3052, i32 0, i32 9
  %3054 = load i64, ptr %27, align 8, !tbaa !24
  %3055 = add nsw i64 %3054, 1
  %3056 = getelementptr inbounds [32 x ptr], ptr %3053, i64 0, i64 %3055
  %3057 = load ptr, ptr %3056, align 8, !tbaa !5
  %3058 = icmp eq ptr %3051, %3057
  br i1 %3058, label %3059, label %3069

3059:                                             ; preds = %3050
  %3060 = load i64, ptr %21, align 8, !tbaa !24
  %3061 = load ptr, ptr %7, align 8, !tbaa !5
  %3062 = getelementptr inbounds %struct.MDBX_cursor, ptr %3061, i32 0, i32 10
  %3063 = load i64, ptr %27, align 8, !tbaa !24
  %3064 = add nsw i64 %3063, 1
  %3065 = getelementptr inbounds [32 x i16], ptr %3062, i64 0, i64 %3064
  %3066 = load i16, ptr %3065, align 2, !tbaa !23
  %3067 = zext i16 %3066 to i64
  %3068 = icmp eq i64 %3060, %3067
  br label %3069

3069:                                             ; preds = %3059, %3050
  %3070 = phi i1 [ false, %3050 ], [ %3068, %3059 ]
  %3071 = xor i1 %3070, true
  %3072 = xor i1 %3071, true
  %3073 = xor i1 %3072, true
  %3074 = zext i1 %3073 to i32
  %3075 = sext i32 %3074 to i64
  %3076 = call i64 @llvm.expect.i64(i64 %3075, i64 0)
  %3077 = icmp ne i64 %3076, 0
  br i1 %3077, label %3078, label %3084

3078:                                             ; preds = %3069
  %3079 = load ptr, ptr %7, align 8, !tbaa !5
  %3080 = getelementptr inbounds %struct.MDBX_cursor, ptr %3079, i32 0, i32 5
  %3081 = load ptr, ptr %3080, align 8, !tbaa !11
  %3082 = getelementptr inbounds %struct.MDBX_txn, ptr %3081, i32 0, i32 9
  %3083 = load ptr, ptr %3082, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %3083, ptr noundef @.str.88, ptr noundef @__func__.page_split, i32 noundef 1301) #11
  unreachable

3084:                                             ; preds = %3069
  br label %3085

3085:                                             ; preds = %3084
  br label %3086

3086:                                             ; preds = %3085
  br label %3087

3087:                                             ; preds = %3086, %3038
  br label %3088

3088:                                             ; preds = %3087
  br label %3089

3089:                                             ; preds = %3088
  %3090 = load ptr, ptr %7, align 8, !tbaa !5
  %3091 = getelementptr inbounds %struct.MDBX_cursor, ptr %3090, i32 0, i32 10
  %3092 = load i64, ptr %27, align 8, !tbaa !24
  %3093 = getelementptr inbounds [32 x i16], ptr %3091, i64 0, i64 %3092
  store i16 0, ptr %3093, align 2, !tbaa !23
  call void @llvm.lifetime.end.p0(i64 8, ptr %67) #10
  br label %3111

3094:                                             ; preds = %2859, %2850
  br label %3095

3095:                                             ; preds = %3094
  %3096 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 5), align 2, !tbaa !25
  %3097 = zext i8 %3096 to i32
  %3098 = icmp sle i32 6, %3097
  %3099 = xor i1 %3098, true
  %3100 = xor i1 %3099, true
  %3101 = zext i1 %3100 to i32
  %3102 = sext i32 %3101 to i64
  %3103 = call i64 @llvm.expect.i64(i64 %3102, i64 0)
  %3104 = icmp ne i64 %3103, 0
  br i1 %3104, label %3105, label %3108

3105:                                             ; preds = %3095
  %3106 = getelementptr inbounds [510 x i8], ptr %19, i64 0, i64 0
  %3107 = call ptr @mdbx_dump_val(ptr noundef %33, ptr noundef %3106, i64 noundef 255)
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef @__func__.page_split, i32 noundef 1304, ptr noundef @.str.89, ptr noundef %3107)
  br label %3108

3108:                                             ; preds = %3105, %3095
  br label %3109

3109:                                             ; preds = %3108
  br label %3110

3110:                                             ; preds = %3109
  br label %3111

3111:                                             ; preds = %3110, %3089
  %3112 = load ptr, ptr %7, align 8, !tbaa !5
  %3113 = getelementptr inbounds %struct.MDBX_cursor, ptr %3112, i32 0, i32 1
  %3114 = getelementptr inbounds %struct.anon.9, ptr %3113, i32 0, i32 1
  %3115 = load i8, ptr %3114, align 1, !tbaa !19
  %3116 = add i8 %3115, 1
  store i8 %3116, ptr %3114, align 1, !tbaa !19
  %3117 = load i32, ptr %13, align 4, !tbaa !9
  %3118 = icmp ne i32 %3117, 0
  %3119 = xor i1 %3118, true
  %3120 = xor i1 %3119, true
  %3121 = zext i1 %3120 to i32
  %3122 = sext i32 %3121 to i64
  %3123 = call i64 @llvm.expect.i64(i64 %3122, i64 0)
  %3124 = icmp ne i64 %3123, 0
  br i1 %3124, label %3125, label %3126

3125:                                             ; preds = %3111
  store i32 14, ptr %23, align 4
  br label %3188

3126:                                             ; preds = %3111
  call void @llvm.lifetime.start.p0(i64 8, ptr %68) #10
  %3127 = load ptr, ptr %7, align 8, !tbaa !5
  %3128 = getelementptr inbounds %struct.MDBX_cursor, ptr %3127, i32 0, i32 9
  %3129 = load i64, ptr %27, align 8, !tbaa !24
  %3130 = getelementptr inbounds [32 x ptr], ptr %3128, i64 0, i64 %3129
  %3131 = load ptr, ptr %3130, align 8, !tbaa !5
  %3132 = load ptr, ptr %7, align 8, !tbaa !5
  %3133 = getelementptr inbounds %struct.MDBX_cursor, ptr %3132, i32 0, i32 10
  %3134 = load i64, ptr %27, align 8, !tbaa !24
  %3135 = getelementptr inbounds [32 x i16], ptr %3133, i64 0, i64 %3134
  %3136 = load i16, ptr %3135, align 2, !tbaa !23
  %3137 = zext i16 %3136 to i64
  %3138 = add i64 %3137, 1
  %3139 = call ptr @page_node(ptr noundef %3131, i64 noundef %3138) #12
  store ptr %3139, ptr %68, align 8, !tbaa !5
  br label %3140

3140:                                             ; preds = %3126
  %3141 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %3142 = zext i8 %3141 to i32
  %3143 = and i32 %3142, 1
  %3144 = icmp ne i32 %3143, 0
  %3145 = xor i1 %3144, true
  %3146 = xor i1 %3145, true
  %3147 = zext i1 %3146 to i32
  %3148 = sext i32 %3147 to i64
  %3149 = call i64 @llvm.expect.i64(i64 %3148, i64 1)
  %3150 = icmp ne i64 %3149, 0
  br i1 %3150, label %3151, label %3185

3151:                                             ; preds = %3140
  br label %3152

3152:                                             ; preds = %3151
  %3153 = load ptr, ptr %68, align 8, !tbaa !5
  %3154 = call i32 @node_pgno(ptr noundef %3153) #12
  %3155 = load ptr, ptr %20, align 8, !tbaa !5
  %3156 = getelementptr inbounds %struct.page, ptr %3155, i32 0, i32 4
  %3157 = load i32, ptr %3156, align 1, !tbaa !9
  %3158 = icmp eq i32 %3154, %3157
  br i1 %3158, label %3159, label %3167

3159:                                             ; preds = %3152
  %3160 = load ptr, ptr %7, align 8, !tbaa !5
  %3161 = getelementptr inbounds %struct.MDBX_cursor, ptr %3160, i32 0, i32 9
  %3162 = load i64, ptr %27, align 8, !tbaa !24
  %3163 = getelementptr inbounds [32 x ptr], ptr %3161, i64 0, i64 %3162
  %3164 = load ptr, ptr %3163, align 8, !tbaa !5
  %3165 = load ptr, ptr %66, align 8, !tbaa !5
  %3166 = icmp eq ptr %3164, %3165
  br label %3167

3167:                                             ; preds = %3159, %3152
  %3168 = phi i1 [ false, %3152 ], [ %3166, %3159 ]
  %3169 = xor i1 %3168, true
  %3170 = xor i1 %3169, true
  %3171 = xor i1 %3170, true
  %3172 = zext i1 %3171 to i32
  %3173 = sext i32 %3172 to i64
  %3174 = call i64 @llvm.expect.i64(i64 %3173, i64 0)
  %3175 = icmp ne i64 %3174, 0
  br i1 %3175, label %3176, label %3182

3176:                                             ; preds = %3167
  %3177 = load ptr, ptr %7, align 8, !tbaa !5
  %3178 = getelementptr inbounds %struct.MDBX_cursor, ptr %3177, i32 0, i32 5
  %3179 = load ptr, ptr %3178, align 8, !tbaa !11
  %3180 = getelementptr inbounds %struct.MDBX_txn, ptr %3179, i32 0, i32 9
  %3181 = load ptr, ptr %3180, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %3181, ptr noundef @.str.90, ptr noundef @__func__.page_split, i32 noundef 1312) #11
  unreachable

3182:                                             ; preds = %3167
  br label %3183

3183:                                             ; preds = %3182
  br label %3184

3184:                                             ; preds = %3183
  br label %3185

3185:                                             ; preds = %3184, %3140
  br label %3186

3186:                                             ; preds = %3185
  br label %3187

3187:                                             ; preds = %3186
  call void @llvm.lifetime.end.p0(i64 8, ptr %68) #10
  store i32 0, ptr %23, align 4
  br label %3188

3188:                                             ; preds = %3187, %3125
  call void @llvm.lifetime.end.p0(i64 8, ptr %66) #10
  %3189 = load i32, ptr %23, align 4
  switch i32 %3189, label %4629 [
    i32 0, label %3190
    i32 14, label %4523
  ]

3190:                                             ; preds = %3188
  br label %3247

3191:                                             ; preds = %2673
  %3192 = load ptr, ptr %31, align 8, !tbaa !5
  %3193 = getelementptr inbounds %struct.MDBX_cursor, ptr %3192, i32 0, i32 1
  %3194 = getelementptr inbounds %struct.anon.9, ptr %3193, i32 0, i32 1
  %3195 = load i8, ptr %3194, align 1, !tbaa !19
  %3196 = sext i8 %3195 to i32
  %3197 = sub nsw i32 %3196, 1
  %3198 = trunc i32 %3197 to i8
  store i8 %3198, ptr %3194, align 1, !tbaa !19
  br label %3199

3199:                                             ; preds = %3191
  %3200 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 5), align 2, !tbaa !25
  %3201 = zext i8 %3200 to i32
  %3202 = icmp sle i32 6, %3201
  %3203 = xor i1 %3202, true
  %3204 = xor i1 %3203, true
  %3205 = zext i1 %3204 to i32
  %3206 = sext i32 %3205 to i64
  %3207 = call i64 @llvm.expect.i64(i64 %3206, i64 0)
  %3208 = icmp ne i64 %3207, 0
  br i1 %3208, label %3209, label %3216

3209:                                             ; preds = %3199
  %3210 = load ptr, ptr %31, align 8, !tbaa !5
  %3211 = getelementptr inbounds %struct.MDBX_cursor, ptr %3210, i32 0, i32 10
  %3212 = load i64, ptr %27, align 8, !tbaa !24
  %3213 = getelementptr inbounds [32 x i16], ptr %3211, i64 0, i64 %3212
  %3214 = load i16, ptr %3213, align 2, !tbaa !23
  %3215 = zext i16 %3214 to i32
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef @__func__.page_split, i32 noundef 1315, ptr noundef @.str.91, i32 noundef %3215)
  br label %3216

3216:                                             ; preds = %3209, %3199
  br label %3217

3217:                                             ; preds = %3216
  br label %3218

3218:                                             ; preds = %3217
  %3219 = load ptr, ptr %31, align 8, !tbaa !5
  %3220 = load ptr, ptr %31, align 8, !tbaa !5
  %3221 = getelementptr inbounds %struct.MDBX_cursor, ptr %3220, i32 0, i32 10
  %3222 = load i64, ptr %27, align 8, !tbaa !24
  %3223 = getelementptr inbounds [32 x i16], ptr %3221, i64 0, i64 %3222
  %3224 = load i16, ptr %3223, align 2, !tbaa !23
  %3225 = zext i16 %3224 to i64
  %3226 = load ptr, ptr %26, align 8, !tbaa !5
  %3227 = getelementptr inbounds %struct.page, ptr %3226, i32 0, i32 4
  %3228 = load i32, ptr %3227, align 1, !tbaa !9
  %3229 = call i32 @node_add_branch(ptr noundef %3219, i64 noundef %3225, ptr noundef %33, i32 noundef %3228)
  store i32 %3229, ptr %13, align 4, !tbaa !9
  %3230 = load ptr, ptr %31, align 8, !tbaa !5
  %3231 = getelementptr inbounds %struct.MDBX_cursor, ptr %3230, i32 0, i32 1
  %3232 = getelementptr inbounds %struct.anon.9, ptr %3231, i32 0, i32 1
  %3233 = load i8, ptr %3232, align 1, !tbaa !19
  %3234 = sext i8 %3233 to i32
  %3235 = add nsw i32 %3234, 1
  %3236 = trunc i32 %3235 to i8
  store i8 %3236, ptr %3232, align 1, !tbaa !19
  %3237 = load i32, ptr %13, align 4, !tbaa !9
  %3238 = icmp ne i32 %3237, 0
  %3239 = xor i1 %3238, true
  %3240 = xor i1 %3239, true
  %3241 = zext i1 %3240 to i32
  %3242 = sext i32 %3241 to i64
  %3243 = call i64 @llvm.expect.i64(i64 %3242, i64 0)
  %3244 = icmp ne i64 %3243, 0
  br i1 %3244, label %3245, label %3246

3245:                                             ; preds = %3218
  br label %4523

3246:                                             ; preds = %3218
  br label %3247

3247:                                             ; preds = %3246, %3190
  br label %3248

3248:                                             ; preds = %3247, %2672
  %3249 = load i8, ptr %39, align 1, !tbaa !44, !range !45, !noundef !46
  %3250 = trunc i8 %3249 to i1
  %3251 = zext i1 %3250 to i32
  %3252 = load i8, ptr %38, align 1, !tbaa !44, !range !45, !noundef !46
  %3253 = trunc i8 %3252 to i1
  %3254 = zext i1 %3253 to i32
  %3255 = or i32 %3251, %3254
  %3256 = icmp ne i32 %3255, 0
  %3257 = xor i1 %3256, true
  %3258 = xor i1 %3257, true
  %3259 = zext i1 %3258 to i32
  %3260 = sext i32 %3259 to i64
  %3261 = call i64 @llvm.expect.i64(i64 %3260, i64 0)
  %3262 = icmp ne i64 %3261, 0
  br i1 %3262, label %3263, label %3608

3263:                                             ; preds = %3248
  %3264 = load ptr, ptr %26, align 8, !tbaa !5
  %3265 = load ptr, ptr %7, align 8, !tbaa !5
  %3266 = getelementptr inbounds %struct.MDBX_cursor, ptr %3265, i32 0, i32 9
  %3267 = load ptr, ptr %7, align 8, !tbaa !5
  %3268 = getelementptr inbounds %struct.MDBX_cursor, ptr %3267, i32 0, i32 1
  %3269 = getelementptr inbounds %struct.anon.9, ptr %3268, i32 0, i32 1
  %3270 = load i8, ptr %3269, align 1, !tbaa !19
  %3271 = sext i8 %3270 to i64
  %3272 = getelementptr inbounds [32 x ptr], ptr %3266, i64 0, i64 %3271
  store ptr %3264, ptr %3272, align 8, !tbaa !5
  %3273 = load ptr, ptr %7, align 8, !tbaa !5
  %3274 = getelementptr inbounds %struct.MDBX_cursor, ptr %3273, i32 0, i32 10
  %3275 = load ptr, ptr %7, align 8, !tbaa !5
  %3276 = getelementptr inbounds %struct.MDBX_cursor, ptr %3275, i32 0, i32 1
  %3277 = getelementptr inbounds %struct.anon.9, ptr %3276, i32 0, i32 1
  %3278 = load i8, ptr %3277, align 1, !tbaa !19
  %3279 = sext i8 %3278 to i64
  %3280 = getelementptr inbounds [32 x i16], ptr %3274, i64 0, i64 %3279
  store i16 0, ptr %3280, align 2, !tbaa !23
  %3281 = load ptr, ptr %26, align 8, !tbaa !5
  %3282 = call zeroext i8 @page_type(ptr noundef %3281) #12
  %3283 = zext i8 %3282 to i32
  switch i32 %3283, label %3407 [
    i32 2, label %3284
    i32 34, label %3329
  ]

3284:                                             ; preds = %3263
  br label %3285

3285:                                             ; preds = %3284
  %3286 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %3287 = zext i8 %3286 to i32
  %3288 = and i32 %3287, 1
  %3289 = icmp ne i32 %3288, 0
  %3290 = xor i1 %3289, true
  %3291 = xor i1 %3290, true
  %3292 = zext i1 %3291 to i32
  %3293 = sext i32 %3292 to i64
  %3294 = call i64 @llvm.expect.i64(i64 %3293, i64 1)
  %3295 = icmp ne i64 %3294, 0
  br i1 %3295, label %3296, label %3321

3296:                                             ; preds = %3285
  br label %3297

3297:                                             ; preds = %3296
  %3298 = load i32, ptr %10, align 4, !tbaa !9
  %3299 = icmp eq i32 %3298, 0
  br i1 %3299, label %3303, label %3300

3300:                                             ; preds = %3297
  %3301 = load i32, ptr %10, align 4, !tbaa !9
  %3302 = icmp eq i32 %3301, -1
  br label %3303

3303:                                             ; preds = %3300, %3297
  %3304 = phi i1 [ true, %3297 ], [ %3302, %3300 ]
  %3305 = xor i1 %3304, true
  %3306 = xor i1 %3305, true
  %3307 = xor i1 %3306, true
  %3308 = zext i1 %3307 to i32
  %3309 = sext i32 %3308 to i64
  %3310 = call i64 @llvm.expect.i64(i64 %3309, i64 0)
  %3311 = icmp ne i64 %3310, 0
  br i1 %3311, label %3312, label %3318

3312:                                             ; preds = %3303
  %3313 = load ptr, ptr %7, align 8, !tbaa !5
  %3314 = getelementptr inbounds %struct.MDBX_cursor, ptr %3313, i32 0, i32 5
  %3315 = load ptr, ptr %3314, align 8, !tbaa !11
  %3316 = getelementptr inbounds %struct.MDBX_txn, ptr %3315, i32 0, i32 9
  %3317 = load ptr, ptr %3316, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %3317, ptr noundef @.str.92, ptr noundef @__func__.page_split, i32 noundef 1327) #11
  unreachable

3318:                                             ; preds = %3303
  br label %3319

3319:                                             ; preds = %3318
  br label %3320

3320:                                             ; preds = %3319
  br label %3321

3321:                                             ; preds = %3320, %3285
  br label %3322

3322:                                             ; preds = %3321
  br label %3323

3323:                                             ; preds = %3322
  %3324 = load ptr, ptr %7, align 8, !tbaa !5
  %3325 = load ptr, ptr %8, align 8, !tbaa !5
  %3326 = load ptr, ptr %9, align 8, !tbaa !5
  %3327 = load i32, ptr %11, align 4, !tbaa !9
  %3328 = call i32 @node_add_leaf(ptr noundef %3324, i64 noundef 0, ptr noundef %3325, ptr noundef %3326, i32 noundef %3327)
  store i32 %3328, ptr %13, align 4, !tbaa !9
  br label %3413

3329:                                             ; preds = %3263
  br label %3330

3330:                                             ; preds = %3329
  %3331 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %3332 = zext i8 %3331 to i32
  %3333 = and i32 %3332, 1
  %3334 = icmp ne i32 %3333, 0
  %3335 = xor i1 %3334, true
  %3336 = xor i1 %3335, true
  %3337 = zext i1 %3336 to i32
  %3338 = sext i32 %3337 to i64
  %3339 = call i64 @llvm.expect.i64(i64 %3338, i64 1)
  %3340 = icmp ne i64 %3339, 0
  br i1 %3340, label %3341, label %3362

3341:                                             ; preds = %3330
  br label %3342

3342:                                             ; preds = %3341
  %3343 = load i32, ptr %11, align 4, !tbaa !9
  %3344 = and i32 %3343, 7
  %3345 = icmp eq i32 %3344, 0
  %3346 = xor i1 %3345, true
  %3347 = xor i1 %3346, true
  %3348 = xor i1 %3347, true
  %3349 = zext i1 %3348 to i32
  %3350 = sext i32 %3349 to i64
  %3351 = call i64 @llvm.expect.i64(i64 %3350, i64 0)
  %3352 = icmp ne i64 %3351, 0
  br i1 %3352, label %3353, label %3359

3353:                                             ; preds = %3342
  %3354 = load ptr, ptr %7, align 8, !tbaa !5
  %3355 = getelementptr inbounds %struct.MDBX_cursor, ptr %3354, i32 0, i32 5
  %3356 = load ptr, ptr %3355, align 8, !tbaa !11
  %3357 = getelementptr inbounds %struct.MDBX_txn, ptr %3356, i32 0, i32 9
  %3358 = load ptr, ptr %3357, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %3358, ptr noundef @.str.93, ptr noundef @__func__.page_split, i32 noundef 1331) #11
  unreachable

3359:                                             ; preds = %3342
  br label %3360

3360:                                             ; preds = %3359
  br label %3361

3361:                                             ; preds = %3360
  br label %3362

3362:                                             ; preds = %3361, %3330
  br label %3363

3363:                                             ; preds = %3362
  br label %3364

3364:                                             ; preds = %3363
  br label %3365

3365:                                             ; preds = %3364
  %3366 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %3367 = zext i8 %3366 to i32
  %3368 = and i32 %3367, 1
  %3369 = icmp ne i32 %3368, 0
  %3370 = xor i1 %3369, true
  %3371 = xor i1 %3370, true
  %3372 = zext i1 %3371 to i32
  %3373 = sext i32 %3372 to i64
  %3374 = call i64 @llvm.expect.i64(i64 %3373, i64 1)
  %3375 = icmp ne i64 %3374, 0
  br i1 %3375, label %3376, label %3401

3376:                                             ; preds = %3365
  br label %3377

3377:                                             ; preds = %3376
  %3378 = load i32, ptr %10, align 4, !tbaa !9
  %3379 = icmp eq i32 %3378, 0
  br i1 %3379, label %3383, label %3380

3380:                                             ; preds = %3377
  %3381 = load i32, ptr %10, align 4, !tbaa !9
  %3382 = icmp eq i32 %3381, -1
  br label %3383

3383:                                             ; preds = %3380, %3377
  %3384 = phi i1 [ true, %3377 ], [ %3382, %3380 ]
  %3385 = xor i1 %3384, true
  %3386 = xor i1 %3385, true
  %3387 = xor i1 %3386, true
  %3388 = zext i1 %3387 to i32
  %3389 = sext i32 %3388 to i64
  %3390 = call i64 @llvm.expect.i64(i64 %3389, i64 0)
  %3391 = icmp ne i64 %3390, 0
  br i1 %3391, label %3392, label %3398

3392:                                             ; preds = %3383
  %3393 = load ptr, ptr %7, align 8, !tbaa !5
  %3394 = getelementptr inbounds %struct.MDBX_cursor, ptr %3393, i32 0, i32 5
  %3395 = load ptr, ptr %3394, align 8, !tbaa !11
  %3396 = getelementptr inbounds %struct.MDBX_txn, ptr %3395, i32 0, i32 9
  %3397 = load ptr, ptr %3396, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %3397, ptr noundef @.str.92, ptr noundef @__func__.page_split, i32 noundef 1332) #11
  unreachable

3398:                                             ; preds = %3383
  br label %3399

3399:                                             ; preds = %3398
  br label %3400

3400:                                             ; preds = %3399
  br label %3401

3401:                                             ; preds = %3400, %3365
  br label %3402

3402:                                             ; preds = %3401
  br label %3403

3403:                                             ; preds = %3402
  %3404 = load ptr, ptr %7, align 8, !tbaa !5
  %3405 = load ptr, ptr %8, align 8, !tbaa !5
  %3406 = call i32 @node_add_dupfix(ptr noundef %3404, i64 noundef 0, ptr noundef %3405)
  store i32 %3406, ptr %13, align 4, !tbaa !9
  br label %3413

3407:                                             ; preds = %3263
  %3408 = load ptr, ptr %26, align 8, !tbaa !5
  %3409 = load ptr, ptr %26, align 8, !tbaa !5
  %3410 = call zeroext i8 @page_type(ptr noundef %3409) #12
  %3411 = zext i8 %3410 to i32
  %3412 = call i32 (ptr, ptr, ...) @bad_page(ptr noundef %3408, ptr noundef @.str.94, i32 noundef %3411)
  store i32 %3412, ptr %13, align 4, !tbaa !9
  br label %3413

3413:                                             ; preds = %3407, %3403, %3323
  %3414 = load i32, ptr %13, align 4, !tbaa !9
  %3415 = icmp ne i32 %3414, 0
  %3416 = xor i1 %3415, true
  %3417 = xor i1 %3416, true
  %3418 = zext i1 %3417 to i32
  %3419 = sext i32 %3418 to i64
  %3420 = call i64 @llvm.expect.i64(i64 %3419, i64 0)
  %3421 = icmp ne i64 %3420, 0
  br i1 %3421, label %3422, label %3423

3422:                                             ; preds = %3413
  br label %4523

3423:                                             ; preds = %3413
  %3424 = load i8, ptr %38, align 1, !tbaa !44, !range !45, !noundef !46
  %3425 = trunc i8 %3424 to i1
  br i1 %3425, label %3426, label %3450

3426:                                             ; preds = %3423
  call void @llvm.lifetime.start.p0(i64 8, ptr %69) #10
  store i64 0, ptr %69, align 8, !tbaa !24
  br label %3427

3427:                                             ; preds = %3446, %3426
  %3428 = load i64, ptr %69, align 8, !tbaa !24
  %3429 = load ptr, ptr %7, align 8, !tbaa !5
  %3430 = getelementptr inbounds %struct.MDBX_cursor, ptr %3429, i32 0, i32 1
  %3431 = getelementptr inbounds %struct.anon.9, ptr %3430, i32 0, i32 1
  %3432 = load i8, ptr %3431, align 1, !tbaa !19
  %3433 = sext i8 %3432 to i64
  %3434 = icmp slt i64 %3428, %3433
  br i1 %3434, label %3436, label %3435

3435:                                             ; preds = %3427
  store i32 202, ptr %23, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %69) #10
  br label %3449

3436:                                             ; preds = %3427
  %3437 = load ptr, ptr %31, align 8, !tbaa !5
  %3438 = getelementptr inbounds %struct.MDBX_cursor, ptr %3437, i32 0, i32 10
  %3439 = load i64, ptr %69, align 8, !tbaa !24
  %3440 = getelementptr inbounds [32 x i16], ptr %3438, i64 0, i64 %3439
  %3441 = load i16, ptr %3440, align 2, !tbaa !23
  %3442 = load ptr, ptr %7, align 8, !tbaa !5
  %3443 = getelementptr inbounds %struct.MDBX_cursor, ptr %3442, i32 0, i32 10
  %3444 = load i64, ptr %69, align 8, !tbaa !24
  %3445 = getelementptr inbounds [32 x i16], ptr %3443, i64 0, i64 %3444
  store i16 %3441, ptr %3445, align 2, !tbaa !23
  br label %3446

3446:                                             ; preds = %3436
  %3447 = load i64, ptr %69, align 8, !tbaa !24
  %3448 = add nsw i64 %3447, 1
  store i64 %3448, ptr %69, align 8, !tbaa !24
  br label %3427, !llvm.loop !56

3449:                                             ; preds = %3435
  br label %3607

3450:                                             ; preds = %3423
  %3451 = load ptr, ptr %7, align 8, !tbaa !5
  %3452 = getelementptr inbounds %struct.MDBX_cursor, ptr %3451, i32 0, i32 10
  %3453 = load ptr, ptr %7, align 8, !tbaa !5
  %3454 = getelementptr inbounds %struct.MDBX_cursor, ptr %3453, i32 0, i32 1
  %3455 = getelementptr inbounds %struct.anon.9, ptr %3454, i32 0, i32 1
  %3456 = load i8, ptr %3455, align 1, !tbaa !19
  %3457 = sext i8 %3456 to i32
  %3458 = sub nsw i32 %3457, 1
  %3459 = sext i32 %3458 to i64
  %3460 = getelementptr inbounds [32 x i16], ptr %3452, i64 0, i64 %3459
  %3461 = load i16, ptr %3460, align 2, !tbaa !23
  %3462 = zext i16 %3461 to i32
  %3463 = icmp eq i32 %3462, 0
  br i1 %3463, label %3464, label %3606

3464:                                             ; preds = %3450
  call void @llvm.lifetime.start.p0(i64 8, ptr %70) #10
  store i64 2, ptr %70, align 8, !tbaa !24
  br label %3465

3465:                                             ; preds = %3600, %3464
  %3466 = load i64, ptr %70, align 8, !tbaa !24
  %3467 = load ptr, ptr %7, align 8, !tbaa !5
  %3468 = getelementptr inbounds %struct.MDBX_cursor, ptr %3467, i32 0, i32 1
  %3469 = getelementptr inbounds %struct.anon.9, ptr %3468, i32 0, i32 1
  %3470 = load i8, ptr %3469, align 1, !tbaa !19
  %3471 = sext i8 %3470 to i64
  %3472 = icmp sle i64 %3466, %3471
  br i1 %3472, label %3474, label %3473

3473:                                             ; preds = %3465
  store i32 205, ptr %23, align 4
  br label %3603

3474:                                             ; preds = %3465
  %3475 = load ptr, ptr %7, align 8, !tbaa !5
  %3476 = getelementptr inbounds %struct.MDBX_cursor, ptr %3475, i32 0, i32 10
  %3477 = load ptr, ptr %7, align 8, !tbaa !5
  %3478 = getelementptr inbounds %struct.MDBX_cursor, ptr %3477, i32 0, i32 1
  %3479 = getelementptr inbounds %struct.anon.9, ptr %3478, i32 0, i32 1
  %3480 = load i8, ptr %3479, align 1, !tbaa !19
  %3481 = sext i8 %3480 to i64
  %3482 = load i64, ptr %70, align 8, !tbaa !24
  %3483 = sub nsw i64 %3481, %3482
  %3484 = getelementptr inbounds [32 x i16], ptr %3476, i64 0, i64 %3483
  %3485 = load i16, ptr %3484, align 2, !tbaa !23
  %3486 = icmp ne i16 %3485, 0
  br i1 %3486, label %3487, label %3599

3487:                                             ; preds = %3474
  call void @llvm.lifetime.start.p0(i64 16, ptr %71) #10
  %3488 = load ptr, ptr %7, align 8, !tbaa !5
  %3489 = getelementptr inbounds %struct.MDBX_cursor, ptr %3488, i32 0, i32 9
  %3490 = load ptr, ptr %7, align 8, !tbaa !5
  %3491 = getelementptr inbounds %struct.MDBX_cursor, ptr %3490, i32 0, i32 1
  %3492 = getelementptr inbounds %struct.anon.9, ptr %3491, i32 0, i32 1
  %3493 = load i8, ptr %3492, align 1, !tbaa !19
  %3494 = sext i8 %3493 to i64
  %3495 = load i64, ptr %70, align 8, !tbaa !24
  %3496 = sub nsw i64 %3494, %3495
  %3497 = getelementptr inbounds [32 x ptr], ptr %3489, i64 0, i64 %3496
  %3498 = load ptr, ptr %3497, align 8, !tbaa !5
  %3499 = load ptr, ptr %7, align 8, !tbaa !5
  %3500 = getelementptr inbounds %struct.MDBX_cursor, ptr %3499, i32 0, i32 10
  %3501 = load ptr, ptr %7, align 8, !tbaa !5
  %3502 = getelementptr inbounds %struct.MDBX_cursor, ptr %3501, i32 0, i32 1
  %3503 = getelementptr inbounds %struct.anon.9, ptr %3502, i32 0, i32 1
  %3504 = load i8, ptr %3503, align 1, !tbaa !19
  %3505 = sext i8 %3504 to i64
  %3506 = load i64, ptr %70, align 8, !tbaa !24
  %3507 = sub nsw i64 %3505, %3506
  %3508 = getelementptr inbounds [32 x i16], ptr %3500, i64 0, i64 %3507
  %3509 = load i16, ptr %3508, align 2, !tbaa !23
  %3510 = zext i16 %3509 to i64
  %3511 = call ptr @page_node(ptr noundef %3498, i64 noundef %3510) #12
  %3512 = call { ptr, i64 } @get_key(ptr noundef %3511) #12
  %3513 = getelementptr inbounds { ptr, i64 }, ptr %71, i32 0, i32 0
  %3514 = extractvalue { ptr, i64 } %3512, 0
  store ptr %3514, ptr %3513, align 8
  %3515 = getelementptr inbounds { ptr, i64 }, ptr %71, i32 0, i32 1
  %3516 = extractvalue { ptr, i64 } %3512, 1
  store i64 %3516, ptr %3515, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %33, ptr align 8 %71, i64 16, i1 false), !tbaa.struct !36
  call void @llvm.lifetime.end.p0(i64 16, ptr %71) #10
  %3517 = load ptr, ptr %7, align 8, !tbaa !5
  %3518 = getelementptr inbounds %struct.MDBX_cursor, ptr %3517, i32 0, i32 7
  %3519 = load ptr, ptr %3518, align 8, !tbaa !37
  %3520 = getelementptr inbounds %struct.clc2, ptr %3519, i32 0, i32 0
  %3521 = getelementptr inbounds %struct.clc, ptr %3520, i32 0, i32 0
  %3522 = load ptr, ptr %3521, align 8, !tbaa !38
  %3523 = load ptr, ptr %8, align 8, !tbaa !5
  %3524 = call i32 %3522(ptr noundef %3523, ptr noundef %33)
  %3525 = icmp slt i32 %3524, 0
  br i1 %3525, label %3526, label %3598

3526:                                             ; preds = %3487
  %3527 = load i64, ptr %70, align 8, !tbaa !24
  %3528 = trunc i64 %3527 to i8
  %3529 = sext i8 %3528 to i32
  %3530 = load ptr, ptr %7, align 8, !tbaa !5
  %3531 = getelementptr inbounds %struct.MDBX_cursor, ptr %3530, i32 0, i32 1
  %3532 = getelementptr inbounds %struct.anon.9, ptr %3531, i32 0, i32 1
  %3533 = load i8, ptr %3532, align 1, !tbaa !19
  %3534 = sext i8 %3533 to i32
  %3535 = sub nsw i32 %3534, %3529
  %3536 = trunc i32 %3535 to i8
  store i8 %3536, ptr %3532, align 1, !tbaa !19
  br label %3537

3537:                                             ; preds = %3526
  %3538 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 5), align 2, !tbaa !25
  %3539 = zext i8 %3538 to i32
  %3540 = icmp sle i32 5, %3539
  %3541 = xor i1 %3540, true
  %3542 = xor i1 %3541, true
  %3543 = zext i1 %3542 to i32
  %3544 = sext i32 %3543 to i64
  %3545 = call i64 @llvm.expect.i64(i64 %3544, i64 0)
  %3546 = icmp ne i64 %3545, 0
  br i1 %3546, label %3547, label %3572

3547:                                             ; preds = %3537
  %3548 = load ptr, ptr %7, align 8, !tbaa !5
  %3549 = getelementptr inbounds %struct.MDBX_cursor, ptr %3548, i32 0, i32 10
  %3550 = load ptr, ptr %7, align 8, !tbaa !5
  %3551 = getelementptr inbounds %struct.MDBX_cursor, ptr %3550, i32 0, i32 1
  %3552 = getelementptr inbounds %struct.anon.9, ptr %3551, i32 0, i32 1
  %3553 = load i8, ptr %3552, align 1, !tbaa !19
  %3554 = sext i8 %3553 to i64
  %3555 = getelementptr inbounds [32 x i16], ptr %3549, i64 0, i64 %3554
  %3556 = load i16, ptr %3555, align 2, !tbaa !23
  %3557 = zext i16 %3556 to i32
  %3558 = load ptr, ptr %7, align 8, !tbaa !5
  %3559 = getelementptr inbounds %struct.MDBX_cursor, ptr %3558, i32 0, i32 9
  %3560 = load ptr, ptr %7, align 8, !tbaa !5
  %3561 = getelementptr inbounds %struct.MDBX_cursor, ptr %3560, i32 0, i32 1
  %3562 = getelementptr inbounds %struct.anon.9, ptr %3561, i32 0, i32 1
  %3563 = load i8, ptr %3562, align 1, !tbaa !19
  %3564 = sext i8 %3563 to i64
  %3565 = getelementptr inbounds [32 x ptr], ptr %3559, i64 0, i64 %3564
  %3566 = load ptr, ptr %3565, align 8, !tbaa !5
  %3567 = getelementptr inbounds %struct.page, ptr %3566, i32 0, i32 4
  %3568 = load i32, ptr %3567, align 1, !tbaa !9
  %3569 = load ptr, ptr %8, align 8, !tbaa !5
  %3570 = getelementptr inbounds [510 x i8], ptr %19, i64 0, i64 0
  %3571 = call ptr @mdbx_dump_val(ptr noundef %3569, ptr noundef %3570, i64 noundef 255)
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 5, ptr noundef @__func__.page_split, i32 noundef 1351, ptr noundef @.str.95, i32 noundef %3557, i32 noundef %3568, ptr noundef %3571)
  br label %3572

3572:                                             ; preds = %3547, %3537
  br label %3573

3573:                                             ; preds = %3572
  br label %3574

3574:                                             ; preds = %3573
  %3575 = load ptr, ptr %7, align 8, !tbaa !5
  %3576 = load ptr, ptr %8, align 8, !tbaa !5
  %3577 = call i32 @tree_propagate_key(ptr noundef %3575, ptr noundef %3576)
  store i32 %3577, ptr %13, align 4, !tbaa !9
  %3578 = load i64, ptr %70, align 8, !tbaa !24
  %3579 = trunc i64 %3578 to i8
  %3580 = sext i8 %3579 to i32
  %3581 = load ptr, ptr %7, align 8, !tbaa !5
  %3582 = getelementptr inbounds %struct.MDBX_cursor, ptr %3581, i32 0, i32 1
  %3583 = getelementptr inbounds %struct.anon.9, ptr %3582, i32 0, i32 1
  %3584 = load i8, ptr %3583, align 1, !tbaa !19
  %3585 = sext i8 %3584 to i32
  %3586 = add nsw i32 %3585, %3580
  %3587 = trunc i32 %3586 to i8
  store i8 %3587, ptr %3583, align 1, !tbaa !19
  %3588 = load i32, ptr %13, align 4, !tbaa !9
  %3589 = icmp ne i32 %3588, 0
  %3590 = xor i1 %3589, true
  %3591 = xor i1 %3590, true
  %3592 = zext i1 %3591 to i32
  %3593 = sext i32 %3592 to i64
  %3594 = call i64 @llvm.expect.i64(i64 %3593, i64 0)
  %3595 = icmp ne i64 %3594, 0
  br i1 %3595, label %3596, label %3597

3596:                                             ; preds = %3574
  store i32 14, ptr %23, align 4
  br label %3603

3597:                                             ; preds = %3574
  br label %3598

3598:                                             ; preds = %3597, %3487
  store i32 205, ptr %23, align 4
  br label %3603

3599:                                             ; preds = %3474
  br label %3600

3600:                                             ; preds = %3599
  %3601 = load i64, ptr %70, align 8, !tbaa !24
  %3602 = add nsw i64 %3601, 1
  store i64 %3602, ptr %70, align 8, !tbaa !24
  br label %3465, !llvm.loop !57

3603:                                             ; preds = %3598, %3596, %3473
  call void @llvm.lifetime.end.p0(i64 8, ptr %70) #10
  %3604 = load i32, ptr %23, align 4
  switch i32 %3604, label %4629 [
    i32 205, label %3605
    i32 14, label %4523
  ]

3605:                                             ; preds = %3603
  br label %3606

3606:                                             ; preds = %3605, %3450
  br label %3607

3607:                                             ; preds = %3606, %3449
  br label %4132

3608:                                             ; preds = %3248
  %3609 = load ptr, ptr %18, align 8, !tbaa !5
  %3610 = icmp ne ptr %3609, null
  br i1 %3610, label %3611, label %4055

3611:                                             ; preds = %3608
  %3612 = load ptr, ptr %26, align 8, !tbaa !5
  %3613 = load ptr, ptr %7, align 8, !tbaa !5
  %3614 = getelementptr inbounds %struct.MDBX_cursor, ptr %3613, i32 0, i32 9
  %3615 = load ptr, ptr %7, align 8, !tbaa !5
  %3616 = getelementptr inbounds %struct.MDBX_cursor, ptr %3615, i32 0, i32 1
  %3617 = getelementptr inbounds %struct.anon.9, ptr %3616, i32 0, i32 1
  %3618 = load i8, ptr %3617, align 1, !tbaa !19
  %3619 = sext i8 %3618 to i64
  %3620 = getelementptr inbounds [32 x ptr], ptr %3614, i64 0, i64 %3619
  store ptr %3612, ptr %3620, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %72) #10
  store i64 0, ptr %72, align 8, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 8, ptr %73) #10
  %3621 = load i64, ptr %32, align 8, !tbaa !24
  store i64 %3621, ptr %73, align 8, !tbaa !24
  br label %3622

3622:                                             ; preds = %3880, %3611
  br label %3623

3623:                                             ; preds = %3622
  %3624 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 5), align 2, !tbaa !25
  %3625 = zext i8 %3624 to i32
  %3626 = icmp sle i32 6, %3625
  %3627 = xor i1 %3626, true
  %3628 = xor i1 %3627, true
  %3629 = zext i1 %3628 to i32
  %3630 = sext i32 %3629 to i64
  %3631 = call i64 @llvm.expect.i64(i64 %3630, i64 0)
  %3632 = icmp ne i64 %3631, 0
  br i1 %3632, label %3633, label %3640

3633:                                             ; preds = %3623
  %3634 = load i64, ptr %73, align 8, !tbaa !24
  %3635 = load i64, ptr %22, align 8, !tbaa !24
  %3636 = load i64, ptr %72, align 8, !tbaa !24
  %3637 = load ptr, ptr %26, align 8, !tbaa !5
  %3638 = getelementptr inbounds %struct.page, ptr %3637, i32 0, i32 4
  %3639 = load i32, ptr %3638, align 1, !tbaa !9
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef @__func__.page_split, i32 noundef 1365, ptr noundef @.str.96, i64 noundef %3634, i64 noundef %3635, i64 noundef %3636, i32 noundef %3639)
  br label %3640

3640:                                             ; preds = %3633, %3623
  br label %3641

3641:                                             ; preds = %3640
  br label %3642

3642:                                             ; preds = %3641
  call void @llvm.lifetime.start.p0(i64 4, ptr %74) #10
  store i32 0, ptr %74, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %75) #10
  store ptr null, ptr %75, align 8, !tbaa !5
  %3643 = load i64, ptr %73, align 8, !tbaa !24
  %3644 = load i64, ptr %21, align 8, !tbaa !24
  %3645 = icmp eq i64 %3643, %3644
  br i1 %3645, label %3646, label %3666

3646:                                             ; preds = %3642
  %3647 = load ptr, ptr %8, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %16, ptr align 8 %3647, i64 16, i1 false), !tbaa.struct !36
  %3648 = load ptr, ptr %20, align 8, !tbaa !5
  %3649 = call zeroext i1 @is_leaf(ptr noundef %3648) #12
  br i1 %3649, label %3650, label %3652

3650:                                             ; preds = %3646
  %3651 = load ptr, ptr %9, align 8, !tbaa !5
  store ptr %3651, ptr %75, align 8, !tbaa !5
  br label %3654

3652:                                             ; preds = %3646
  %3653 = load i32, ptr %10, align 4, !tbaa !9
  store i32 %3653, ptr %74, align 4, !tbaa !9
  br label %3654

3654:                                             ; preds = %3652, %3650
  %3655 = load i32, ptr %11, align 4, !tbaa !9
  store i32 %3655, ptr %12, align 4, !tbaa !9
  %3656 = load i64, ptr %72, align 8, !tbaa !24
  %3657 = trunc i64 %3656 to i16
  %3658 = load ptr, ptr %7, align 8, !tbaa !5
  %3659 = getelementptr inbounds %struct.MDBX_cursor, ptr %3658, i32 0, i32 10
  %3660 = load ptr, ptr %7, align 8, !tbaa !5
  %3661 = getelementptr inbounds %struct.MDBX_cursor, ptr %3660, i32 0, i32 1
  %3662 = getelementptr inbounds %struct.anon.9, ptr %3661, i32 0, i32 1
  %3663 = load i8, ptr %3662, align 1, !tbaa !19
  %3664 = sext i8 %3663 to i64
  %3665 = getelementptr inbounds [32 x i16], ptr %3659, i64 0, i64 %3664
  store i16 %3657, ptr %3665, align 2, !tbaa !23
  br label %3701

3666:                                             ; preds = %3642
  call void @llvm.lifetime.start.p0(i64 8, ptr %76) #10
  %3667 = load ptr, ptr %20, align 8, !tbaa !5
  %3668 = ptrtoint ptr %3667 to i64
  %3669 = load ptr, ptr %18, align 8, !tbaa !5
  %3670 = getelementptr inbounds %struct.page, ptr %3669, i32 0, i32 5
  %3671 = load i64, ptr %73, align 8, !tbaa !24
  %3672 = getelementptr inbounds [0 x i16], ptr %3670, i64 0, i64 %3671
  %3673 = load i16, ptr %3672, align 1, !tbaa !23
  %3674 = zext i16 %3673 to i32
  %3675 = add i32 %3674, 20
  %3676 = zext i32 %3675 to i64
  %3677 = add nsw i64 %3668, %3676
  %3678 = inttoptr i64 %3677 to ptr
  store ptr %3678, ptr %76, align 8, !tbaa !5
  %3679 = load ptr, ptr %76, align 8, !tbaa !5
  %3680 = call ptr @node_key(ptr noundef %3679) #12
  %3681 = getelementptr inbounds %struct.iovec, ptr %16, i32 0, i32 0
  store ptr %3680, ptr %3681, align 8, !tbaa !47
  %3682 = load ptr, ptr %76, align 8, !tbaa !5
  %3683 = call i64 @node_ks(ptr noundef %3682) #12
  %3684 = getelementptr inbounds %struct.iovec, ptr %16, i32 0, i32 1
  store i64 %3683, ptr %3684, align 8, !tbaa !26
  %3685 = load ptr, ptr %20, align 8, !tbaa !5
  %3686 = call zeroext i1 @is_leaf(ptr noundef %3685) #12
  br i1 %3686, label %3687, label %3694

3687:                                             ; preds = %3666
  %3688 = load ptr, ptr %76, align 8, !tbaa !5
  %3689 = call ptr @node_data(ptr noundef %3688) #12
  %3690 = getelementptr inbounds %struct.iovec, ptr %17, i32 0, i32 0
  store ptr %3689, ptr %3690, align 8, !tbaa !47
  %3691 = load ptr, ptr %76, align 8, !tbaa !5
  %3692 = call i64 @node_ds(ptr noundef %3691) #12
  %3693 = getelementptr inbounds %struct.iovec, ptr %17, i32 0, i32 1
  store i64 %3692, ptr %3693, align 8, !tbaa !26
  store ptr %17, ptr %75, align 8, !tbaa !5
  br label %3697

3694:                                             ; preds = %3666
  %3695 = load ptr, ptr %76, align 8, !tbaa !5
  %3696 = call i32 @node_pgno(ptr noundef %3695) #12
  store i32 %3696, ptr %74, align 4, !tbaa !9
  br label %3697

3697:                                             ; preds = %3694, %3687
  %3698 = load ptr, ptr %76, align 8, !tbaa !5
  %3699 = call zeroext i8 @node_flags(ptr noundef %3698) #12
  %3700 = zext i8 %3699 to i32
  store i32 %3700, ptr %12, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %76) #10
  br label %3701

3701:                                             ; preds = %3697, %3654
  %3702 = load ptr, ptr %26, align 8, !tbaa !5
  %3703 = call zeroext i8 @page_type(ptr noundef %3702) #12
  %3704 = zext i8 %3703 to i32
  switch i32 %3704, label %3826 [
    i32 1, label %3705
    i32 2, label %3752
  ]

3705:                                             ; preds = %3701
  br label %3706

3706:                                             ; preds = %3705
  %3707 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %3708 = zext i8 %3707 to i32
  %3709 = and i32 %3708, 1
  %3710 = icmp ne i32 %3709, 0
  %3711 = xor i1 %3710, true
  %3712 = xor i1 %3711, true
  %3713 = zext i1 %3712 to i32
  %3714 = sext i32 %3713 to i64
  %3715 = call i64 @llvm.expect.i64(i64 %3714, i64 1)
  %3716 = icmp ne i64 %3715, 0
  br i1 %3716, label %3717, label %3739

3717:                                             ; preds = %3706
  br label %3718

3718:                                             ; preds = %3717
  %3719 = load i32, ptr %12, align 4, !tbaa !9
  %3720 = trunc i32 %3719 to i16
  %3721 = zext i16 %3720 to i32
  %3722 = icmp eq i32 0, %3721
  %3723 = xor i1 %3722, true
  %3724 = xor i1 %3723, true
  %3725 = xor i1 %3724, true
  %3726 = zext i1 %3725 to i32
  %3727 = sext i32 %3726 to i64
  %3728 = call i64 @llvm.expect.i64(i64 %3727, i64 0)
  %3729 = icmp ne i64 %3728, 0
  br i1 %3729, label %3730, label %3736

3730:                                             ; preds = %3718
  %3731 = load ptr, ptr %7, align 8, !tbaa !5
  %3732 = getelementptr inbounds %struct.MDBX_cursor, ptr %3731, i32 0, i32 5
  %3733 = load ptr, ptr %3732, align 8, !tbaa !11
  %3734 = getelementptr inbounds %struct.MDBX_txn, ptr %3733, i32 0, i32 9
  %3735 = load ptr, ptr %3734, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %3735, ptr noundef @.str.97, ptr noundef @__func__.page_split, i32 noundef 1392) #11
  unreachable

3736:                                             ; preds = %3718
  br label %3737

3737:                                             ; preds = %3736
  br label %3738

3738:                                             ; preds = %3737
  br label %3739

3739:                                             ; preds = %3738, %3706
  br label %3740

3740:                                             ; preds = %3739
  br label %3741

3741:                                             ; preds = %3740
  %3742 = load ptr, ptr %7, align 8, !tbaa !5
  %3743 = load i64, ptr %72, align 8, !tbaa !24
  %3744 = load i64, ptr %72, align 8, !tbaa !24
  %3745 = icmp ne i64 %3744, 0
  br i1 %3745, label %3746, label %3747

3746:                                             ; preds = %3741
  br label %3748

3747:                                             ; preds = %3741
  br label %3748

3748:                                             ; preds = %3747, %3746
  %3749 = phi ptr [ %16, %3746 ], [ null, %3747 ]
  %3750 = load i32, ptr %74, align 4, !tbaa !9
  %3751 = call i32 @node_add_branch(ptr noundef %3742, i64 noundef %3743, ptr noundef %3749, i32 noundef %3750)
  store i32 %3751, ptr %13, align 4, !tbaa !9
  br label %3832

3752:                                             ; preds = %3701
  br label %3753

3753:                                             ; preds = %3752
  %3754 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %3755 = zext i8 %3754 to i32
  %3756 = and i32 %3755, 1
  %3757 = icmp ne i32 %3756, 0
  %3758 = xor i1 %3757, true
  %3759 = xor i1 %3758, true
  %3760 = zext i1 %3759 to i32
  %3761 = sext i32 %3760 to i64
  %3762 = call i64 @llvm.expect.i64(i64 %3761, i64 1)
  %3763 = icmp ne i64 %3762, 0
  br i1 %3763, label %3764, label %3784

3764:                                             ; preds = %3753
  br label %3765

3765:                                             ; preds = %3764
  %3766 = load i32, ptr %74, align 4, !tbaa !9
  %3767 = icmp eq i32 %3766, 0
  %3768 = xor i1 %3767, true
  %3769 = xor i1 %3768, true
  %3770 = xor i1 %3769, true
  %3771 = zext i1 %3770 to i32
  %3772 = sext i32 %3771 to i64
  %3773 = call i64 @llvm.expect.i64(i64 %3772, i64 0)
  %3774 = icmp ne i64 %3773, 0
  br i1 %3774, label %3775, label %3781

3775:                                             ; preds = %3765
  %3776 = load ptr, ptr %7, align 8, !tbaa !5
  %3777 = getelementptr inbounds %struct.MDBX_cursor, ptr %3776, i32 0, i32 5
  %3778 = load ptr, ptr %3777, align 8, !tbaa !11
  %3779 = getelementptr inbounds %struct.MDBX_txn, ptr %3778, i32 0, i32 9
  %3780 = load ptr, ptr %3779, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %3780, ptr noundef @.str.98, ptr noundef @__func__.page_split, i32 noundef 1397) #11
  unreachable

3781:                                             ; preds = %3765
  br label %3782

3782:                                             ; preds = %3781
  br label %3783

3783:                                             ; preds = %3782
  br label %3784

3784:                                             ; preds = %3783, %3753
  br label %3785

3785:                                             ; preds = %3784
  br label %3786

3786:                                             ; preds = %3785
  br label %3787

3787:                                             ; preds = %3786
  %3788 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %3789 = zext i8 %3788 to i32
  %3790 = and i32 %3789, 1
  %3791 = icmp ne i32 %3790, 0
  %3792 = xor i1 %3791, true
  %3793 = xor i1 %3792, true
  %3794 = zext i1 %3793 to i32
  %3795 = sext i32 %3794 to i64
  %3796 = call i64 @llvm.expect.i64(i64 %3795, i64 1)
  %3797 = icmp ne i64 %3796, 0
  br i1 %3797, label %3798, label %3818

3798:                                             ; preds = %3787
  br label %3799

3799:                                             ; preds = %3798
  %3800 = load ptr, ptr %75, align 8, !tbaa !5
  %3801 = icmp ne ptr %3800, null
  %3802 = xor i1 %3801, true
  %3803 = xor i1 %3802, true
  %3804 = xor i1 %3803, true
  %3805 = zext i1 %3804 to i32
  %3806 = sext i32 %3805 to i64
  %3807 = call i64 @llvm.expect.i64(i64 %3806, i64 0)
  %3808 = icmp ne i64 %3807, 0
  br i1 %3808, label %3809, label %3815

3809:                                             ; preds = %3799
  %3810 = load ptr, ptr %7, align 8, !tbaa !5
  %3811 = getelementptr inbounds %struct.MDBX_cursor, ptr %3810, i32 0, i32 5
  %3812 = load ptr, ptr %3811, align 8, !tbaa !11
  %3813 = getelementptr inbounds %struct.MDBX_txn, ptr %3812, i32 0, i32 9
  %3814 = load ptr, ptr %3813, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %3814, ptr noundef @.str.99, ptr noundef @__func__.page_split, i32 noundef 1398) #11
  unreachable

3815:                                             ; preds = %3799
  br label %3816

3816:                                             ; preds = %3815
  br label %3817

3817:                                             ; preds = %3816
  br label %3818

3818:                                             ; preds = %3817, %3787
  br label %3819

3819:                                             ; preds = %3818
  br label %3820

3820:                                             ; preds = %3819
  %3821 = load ptr, ptr %7, align 8, !tbaa !5
  %3822 = load i64, ptr %72, align 8, !tbaa !24
  %3823 = load ptr, ptr %75, align 8, !tbaa !5
  %3824 = load i32, ptr %12, align 4, !tbaa !9
  %3825 = call i32 @node_add_leaf(ptr noundef %3821, i64 noundef %3822, ptr noundef %16, ptr noundef %3823, i32 noundef %3824)
  store i32 %3825, ptr %13, align 4, !tbaa !9
  br label %3832

3826:                                             ; preds = %3701
  %3827 = load ptr, ptr %26, align 8, !tbaa !5
  %3828 = load ptr, ptr %26, align 8, !tbaa !5
  %3829 = call zeroext i8 @page_type(ptr noundef %3828) #12
  %3830 = zext i8 %3829 to i32
  %3831 = call i32 (ptr, ptr, ...) @bad_page(ptr noundef %3827, ptr noundef @.str.94, i32 noundef %3830)
  store i32 %3831, ptr %13, align 4, !tbaa !9
  br label %3832

3832:                                             ; preds = %3826, %3820, %3748
  %3833 = load i32, ptr %13, align 4, !tbaa !9
  %3834 = icmp ne i32 %3833, 0
  %3835 = xor i1 %3834, true
  %3836 = xor i1 %3835, true
  %3837 = zext i1 %3836 to i32
  %3838 = sext i32 %3837 to i64
  %3839 = call i64 @llvm.expect.i64(i64 %3838, i64 0)
  %3840 = icmp ne i64 %3839, 0
  br i1 %3840, label %3841, label %3842

3841:                                             ; preds = %3832
  store i32 14, ptr %23, align 4
  br label %3877

3842:                                             ; preds = %3832
  %3843 = load i64, ptr %72, align 8, !tbaa !24
  %3844 = add i64 %3843, 1
  store i64 %3844, ptr %72, align 8, !tbaa !24
  %3845 = load i64, ptr %73, align 8, !tbaa !24
  %3846 = add i64 %3845, 1
  store i64 %3846, ptr %73, align 8, !tbaa !24
  %3847 = load i64, ptr %22, align 8, !tbaa !24
  %3848 = icmp ugt i64 %3846, %3847
  br i1 %3848, label %3849, label %3876

3849:                                             ; preds = %3842
  store i64 0, ptr %73, align 8, !tbaa !24
  store i64 0, ptr %72, align 8, !tbaa !24
  %3850 = load ptr, ptr %18, align 8, !tbaa !5
  %3851 = load ptr, ptr %7, align 8, !tbaa !5
  %3852 = getelementptr inbounds %struct.MDBX_cursor, ptr %3851, i32 0, i32 9
  %3853 = load ptr, ptr %7, align 8, !tbaa !5
  %3854 = getelementptr inbounds %struct.MDBX_cursor, ptr %3853, i32 0, i32 1
  %3855 = getelementptr inbounds %struct.anon.9, ptr %3854, i32 0, i32 1
  %3856 = load i8, ptr %3855, align 1, !tbaa !19
  %3857 = sext i8 %3856 to i64
  %3858 = getelementptr inbounds [32 x ptr], ptr %3852, i64 0, i64 %3857
  store ptr %3850, ptr %3858, align 8, !tbaa !5
  br label %3859

3859:                                             ; preds = %3849
  %3860 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 5), align 2, !tbaa !25
  %3861 = zext i8 %3860 to i32
  %3862 = icmp sle i32 6, %3861
  %3863 = xor i1 %3862, true
  %3864 = xor i1 %3863, true
  %3865 = zext i1 %3864 to i32
  %3866 = sext i32 %3865 to i64
  %3867 = call i64 @llvm.expect.i64(i64 %3866, i64 0)
  %3868 = icmp ne i64 %3867, 0
  br i1 %3868, label %3869, label %3873

3869:                                             ; preds = %3859
  %3870 = load ptr, ptr %18, align 8, !tbaa !5
  %3871 = getelementptr inbounds %struct.page, ptr %3870, i32 0, i32 4
  %3872 = load i32, ptr %3871, align 1, !tbaa !9
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef @__func__.page_split, i32 noundef 1417, ptr noundef @.str.100, i32 noundef %3872)
  br label %3873

3873:                                             ; preds = %3869, %3859
  br label %3874

3874:                                             ; preds = %3873
  br label %3875

3875:                                             ; preds = %3874
  br label %3876

3876:                                             ; preds = %3875, %3842
  store i32 0, ptr %23, align 4
  br label %3877

3877:                                             ; preds = %3876, %3841
  call void @llvm.lifetime.end.p0(i64 8, ptr %75) #10
  call void @llvm.lifetime.end.p0(i64 4, ptr %74) #10
  %3878 = load i32, ptr %23, align 4
  switch i32 %3878, label %4052 [
    i32 0, label %3879
  ]

3879:                                             ; preds = %3877
  br label %3880

3880:                                             ; preds = %3879
  %3881 = load i64, ptr %73, align 8, !tbaa !24
  %3882 = load i64, ptr %32, align 8, !tbaa !24
  %3883 = icmp ne i64 %3881, %3882
  br i1 %3883, label %3622, label %3884, !llvm.loop !58

3884:                                             ; preds = %3880
  br label %3885

3885:                                             ; preds = %3884
  %3886 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 5), align 2, !tbaa !25
  %3887 = zext i8 %3886 to i32
  %3888 = icmp sle i32 6, %3887
  %3889 = xor i1 %3888, true
  %3890 = xor i1 %3889, true
  %3891 = zext i1 %3890 to i32
  %3892 = sext i32 %3891 to i64
  %3893 = call i64 @llvm.expect.i64(i64 %3892, i64 0)
  %3894 = icmp ne i64 %3893, 0
  br i1 %3894, label %3895, label %3910

3895:                                             ; preds = %3885
  %3896 = load i64, ptr %73, align 8, !tbaa !24
  %3897 = load i64, ptr %22, align 8, !tbaa !24
  %3898 = load i64, ptr %72, align 8, !tbaa !24
  %3899 = load ptr, ptr %7, align 8, !tbaa !5
  %3900 = getelementptr inbounds %struct.MDBX_cursor, ptr %3899, i32 0, i32 9
  %3901 = load ptr, ptr %7, align 8, !tbaa !5
  %3902 = getelementptr inbounds %struct.MDBX_cursor, ptr %3901, i32 0, i32 1
  %3903 = getelementptr inbounds %struct.anon.9, ptr %3902, i32 0, i32 1
  %3904 = load i8, ptr %3903, align 1, !tbaa !19
  %3905 = sext i8 %3904 to i64
  %3906 = getelementptr inbounds [32 x ptr], ptr %3900, i64 0, i64 %3905
  %3907 = load ptr, ptr %3906, align 8, !tbaa !5
  %3908 = getelementptr inbounds %struct.page, ptr %3907, i32 0, i32 4
  %3909 = load i32, ptr %3908, align 1, !tbaa !9
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef @__func__.page_split, i32 noundef 1421, ptr noundef @.str.101, i64 noundef %3896, i64 noundef %3897, i64 noundef %3898, i32 noundef %3909)
  br label %3910

3910:                                             ; preds = %3895, %3885
  br label %3911

3911:                                             ; preds = %3910
  br label %3912

3912:                                             ; preds = %3911
  %3913 = load ptr, ptr %18, align 8, !tbaa !5
  %3914 = call i64 @page_numkeys(ptr noundef %3913) #12
  store i64 %3914, ptr %22, align 8, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 8, ptr %77) #10
  store i64 0, ptr %77, align 8, !tbaa !24
  br label %3915

3915:                                             ; preds = %3930, %3912
  %3916 = load i64, ptr %77, align 8, !tbaa !24
  %3917 = load i64, ptr %22, align 8, !tbaa !24
  %3918 = icmp ult i64 %3916, %3917
  br i1 %3918, label %3920, label %3919

3919:                                             ; preds = %3915
  store i32 231, ptr %23, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %77) #10
  br label %3933

3920:                                             ; preds = %3915
  %3921 = load ptr, ptr %18, align 8, !tbaa !5
  %3922 = getelementptr inbounds %struct.page, ptr %3921, i32 0, i32 5
  %3923 = load i64, ptr %77, align 8, !tbaa !24
  %3924 = getelementptr inbounds [0 x i16], ptr %3922, i64 0, i64 %3923
  %3925 = load i16, ptr %3924, align 1, !tbaa !23
  %3926 = load ptr, ptr %20, align 8, !tbaa !5
  %3927 = getelementptr inbounds %struct.page, ptr %3926, i32 0, i32 5
  %3928 = load i64, ptr %77, align 8, !tbaa !24
  %3929 = getelementptr inbounds [0 x i16], ptr %3927, i64 0, i64 %3928
  store i16 %3925, ptr %3929, align 1, !tbaa !23
  br label %3930

3930:                                             ; preds = %3920
  %3931 = load i64, ptr %77, align 8, !tbaa !24
  %3932 = add i64 %3931, 1
  store i64 %3932, ptr %77, align 8, !tbaa !24
  br label %3915, !llvm.loop !59

3933:                                             ; preds = %3919
  %3934 = load ptr, ptr %18, align 8, !tbaa !5
  %3935 = getelementptr inbounds %struct.page, ptr %3934, i32 0, i32 3
  %3936 = getelementptr inbounds %struct.anon.19, ptr %3935, i32 0, i32 0
  %3937 = load i16, ptr %3936, align 1, !tbaa !19
  %3938 = load ptr, ptr %20, align 8, !tbaa !5
  %3939 = getelementptr inbounds %struct.page, ptr %3938, i32 0, i32 3
  %3940 = getelementptr inbounds %struct.anon.19, ptr %3939, i32 0, i32 0
  store i16 %3937, ptr %3940, align 1, !tbaa !19
  %3941 = load ptr, ptr %18, align 8, !tbaa !5
  %3942 = getelementptr inbounds %struct.page, ptr %3941, i32 0, i32 3
  %3943 = getelementptr inbounds %struct.anon.19, ptr %3942, i32 0, i32 1
  %3944 = load i16, ptr %3943, align 1, !tbaa !19
  %3945 = load ptr, ptr %20, align 8, !tbaa !5
  %3946 = getelementptr inbounds %struct.page, ptr %3945, i32 0, i32 3
  %3947 = getelementptr inbounds %struct.anon.19, ptr %3946, i32 0, i32 1
  store i16 %3944, ptr %3947, align 1, !tbaa !19
  %3948 = load ptr, ptr %20, align 8, !tbaa !5
  %3949 = load i64, ptr %22, align 8, !tbaa !24
  %3950 = sub i64 %3949, 1
  %3951 = call ptr @page_node(ptr noundef %3948, i64 noundef %3950) #12
  %3952 = load ptr, ptr %18, align 8, !tbaa !5
  %3953 = load i64, ptr %22, align 8, !tbaa !24
  %3954 = sub i64 %3953, 1
  %3955 = call ptr @page_node(ptr noundef %3952, i64 noundef %3954) #12
  %3956 = load ptr, ptr %15, align 8, !tbaa !5
  %3957 = getelementptr inbounds %struct.MDBX_env, ptr %3956, i32 0, i32 2
  %3958 = load i32, ptr %3957, align 8, !tbaa !60
  %3959 = load ptr, ptr %18, align 8, !tbaa !5
  %3960 = getelementptr inbounds %struct.page, ptr %3959, i32 0, i32 3
  %3961 = getelementptr inbounds %struct.anon.19, ptr %3960, i32 0, i32 1
  %3962 = load i16, ptr %3961, align 1, !tbaa !19
  %3963 = zext i16 %3962 to i32
  %3964 = sub i32 %3958, %3963
  %3965 = sub i32 %3964, 20
  %3966 = zext i32 %3965 to i64
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %3951, ptr align 1 %3955, i64 %3966, i1 false)
  %3967 = load i64, ptr %21, align 8, !tbaa !24
  %3968 = load i64, ptr %32, align 8, !tbaa !24
  %3969 = icmp ult i64 %3967, %3968
  br i1 %3969, label %3970, label %3980

3970:                                             ; preds = %3933
  %3971 = load ptr, ptr %20, align 8, !tbaa !5
  %3972 = load ptr, ptr %7, align 8, !tbaa !5
  %3973 = getelementptr inbounds %struct.MDBX_cursor, ptr %3972, i32 0, i32 9
  %3974 = load ptr, ptr %7, align 8, !tbaa !5
  %3975 = getelementptr inbounds %struct.MDBX_cursor, ptr %3974, i32 0, i32 1
  %3976 = getelementptr inbounds %struct.anon.9, ptr %3975, i32 0, i32 1
  %3977 = load i8, ptr %3976, align 1, !tbaa !19
  %3978 = sext i8 %3977 to i64
  %3979 = getelementptr inbounds [32 x ptr], ptr %3973, i64 0, i64 %3978
  store ptr %3971, ptr %3979, align 8, !tbaa !5
  br label %4051

3980:                                             ; preds = %3933
  %3981 = load ptr, ptr %26, align 8, !tbaa !5
  %3982 = load ptr, ptr %7, align 8, !tbaa !5
  %3983 = getelementptr inbounds %struct.MDBX_cursor, ptr %3982, i32 0, i32 9
  %3984 = load ptr, ptr %7, align 8, !tbaa !5
  %3985 = getelementptr inbounds %struct.MDBX_cursor, ptr %3984, i32 0, i32 1
  %3986 = getelementptr inbounds %struct.anon.9, ptr %3985, i32 0, i32 1
  %3987 = load i8, ptr %3986, align 1, !tbaa !19
  %3988 = sext i8 %3987 to i64
  %3989 = getelementptr inbounds [32 x ptr], ptr %3983, i64 0, i64 %3988
  store ptr %3981, ptr %3989, align 8, !tbaa !5
  %3990 = load ptr, ptr %7, align 8, !tbaa !5
  %3991 = getelementptr inbounds %struct.MDBX_cursor, ptr %3990, i32 0, i32 10
  %3992 = load i64, ptr %27, align 8, !tbaa !24
  %3993 = getelementptr inbounds [32 x i16], ptr %3991, i64 0, i64 %3992
  %3994 = load i16, ptr %3993, align 2, !tbaa !23
  %3995 = add i16 %3994, 1
  store i16 %3995, ptr %3993, align 2, !tbaa !23
  %3996 = load ptr, ptr %31, align 8, !tbaa !5
  %3997 = getelementptr inbounds %struct.MDBX_cursor, ptr %3996, i32 0, i32 9
  %3998 = load i64, ptr %27, align 8, !tbaa !24
  %3999 = getelementptr inbounds [32 x ptr], ptr %3997, i64 0, i64 %3998
  %4000 = load ptr, ptr %3999, align 8, !tbaa !5
  %4001 = load ptr, ptr %7, align 8, !tbaa !5
  %4002 = getelementptr inbounds %struct.MDBX_cursor, ptr %4001, i32 0, i32 9
  %4003 = load i64, ptr %27, align 8, !tbaa !24
  %4004 = getelementptr inbounds [32 x ptr], ptr %4002, i64 0, i64 %4003
  %4005 = load ptr, ptr %4004, align 8, !tbaa !5
  %4006 = icmp ne ptr %4000, %4005
  br i1 %4006, label %4007, label %4050

4007:                                             ; preds = %3980
  %4008 = load ptr, ptr %7, align 8, !tbaa !5
  %4009 = getelementptr inbounds %struct.MDBX_cursor, ptr %4008, i32 0, i32 10
  %4010 = load i64, ptr %27, align 8, !tbaa !24
  %4011 = getelementptr inbounds [32 x i16], ptr %4009, i64 0, i64 %4010
  %4012 = load i16, ptr %4011, align 2, !tbaa !23
  %4013 = zext i16 %4012 to i64
  %4014 = load ptr, ptr %7, align 8, !tbaa !5
  %4015 = getelementptr inbounds %struct.MDBX_cursor, ptr %4014, i32 0, i32 9
  %4016 = load i64, ptr %27, align 8, !tbaa !24
  %4017 = getelementptr inbounds [32 x ptr], ptr %4015, i64 0, i64 %4016
  %4018 = load ptr, ptr %4017, align 8, !tbaa !5
  %4019 = call i64 @page_numkeys(ptr noundef %4018) #12
  %4020 = icmp uge i64 %4013, %4019
  br i1 %4020, label %4021, label %4050

4021:                                             ; preds = %4007
  call void @llvm.lifetime.start.p0(i64 8, ptr %78) #10
  store i64 0, ptr %78, align 8, !tbaa !24
  br label %4022

4022:                                             ; preds = %4046, %4021
  %4023 = load i64, ptr %78, align 8, !tbaa !24
  %4024 = load i64, ptr %27, align 8, !tbaa !24
  %4025 = icmp sle i64 %4023, %4024
  br i1 %4025, label %4027, label %4026

4026:                                             ; preds = %4022
  store i32 234, ptr %23, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %78) #10
  br label %4049

4027:                                             ; preds = %4022
  %4028 = load ptr, ptr %31, align 8, !tbaa !5
  %4029 = getelementptr inbounds %struct.MDBX_cursor, ptr %4028, i32 0, i32 9
  %4030 = load i64, ptr %78, align 8, !tbaa !24
  %4031 = getelementptr inbounds [32 x ptr], ptr %4029, i64 0, i64 %4030
  %4032 = load ptr, ptr %4031, align 8, !tbaa !5
  %4033 = load ptr, ptr %7, align 8, !tbaa !5
  %4034 = getelementptr inbounds %struct.MDBX_cursor, ptr %4033, i32 0, i32 9
  %4035 = load i64, ptr %78, align 8, !tbaa !24
  %4036 = getelementptr inbounds [32 x ptr], ptr %4034, i64 0, i64 %4035
  store ptr %4032, ptr %4036, align 8, !tbaa !5
  %4037 = load ptr, ptr %31, align 8, !tbaa !5
  %4038 = getelementptr inbounds %struct.MDBX_cursor, ptr %4037, i32 0, i32 10
  %4039 = load i64, ptr %78, align 8, !tbaa !24
  %4040 = getelementptr inbounds [32 x i16], ptr %4038, i64 0, i64 %4039
  %4041 = load i16, ptr %4040, align 2, !tbaa !23
  %4042 = load ptr, ptr %7, align 8, !tbaa !5
  %4043 = getelementptr inbounds %struct.MDBX_cursor, ptr %4042, i32 0, i32 10
  %4044 = load i64, ptr %78, align 8, !tbaa !24
  %4045 = getelementptr inbounds [32 x i16], ptr %4043, i64 0, i64 %4044
  store i16 %4041, ptr %4045, align 2, !tbaa !23
  br label %4046

4046:                                             ; preds = %4027
  %4047 = load i64, ptr %78, align 8, !tbaa !24
  %4048 = add nsw i64 %4047, 1
  store i64 %4048, ptr %78, align 8, !tbaa !24
  br label %4022, !llvm.loop !69

4049:                                             ; preds = %4026
  br label %4050

4050:                                             ; preds = %4049, %4007, %3980
  br label %4051

4051:                                             ; preds = %4050, %3970
  store i32 0, ptr %23, align 4
  br label %4052

4052:                                             ; preds = %4051, %3877
  call void @llvm.lifetime.end.p0(i64 8, ptr %73) #10
  call void @llvm.lifetime.end.p0(i64 8, ptr %72) #10
  %4053 = load i32, ptr %23, align 4
  switch i32 %4053, label %4629 [
    i32 0, label %4054
    i32 14, label %4523
  ]

4054:                                             ; preds = %4052
  br label %4131

4055:                                             ; preds = %3608
  %4056 = load i64, ptr %21, align 8, !tbaa !24
  %4057 = load i64, ptr %32, align 8, !tbaa !24
  %4058 = icmp uge i64 %4056, %4057
  br i1 %4058, label %4059, label %4130

4059:                                             ; preds = %4055
  %4060 = load ptr, ptr %26, align 8, !tbaa !5
  %4061 = load ptr, ptr %7, align 8, !tbaa !5
  %4062 = getelementptr inbounds %struct.MDBX_cursor, ptr %4061, i32 0, i32 9
  %4063 = load ptr, ptr %7, align 8, !tbaa !5
  %4064 = getelementptr inbounds %struct.MDBX_cursor, ptr %4063, i32 0, i32 1
  %4065 = getelementptr inbounds %struct.anon.9, ptr %4064, i32 0, i32 1
  %4066 = load i8, ptr %4065, align 1, !tbaa !19
  %4067 = sext i8 %4066 to i64
  %4068 = getelementptr inbounds [32 x ptr], ptr %4062, i64 0, i64 %4067
  store ptr %4060, ptr %4068, align 8, !tbaa !5
  %4069 = load ptr, ptr %7, align 8, !tbaa !5
  %4070 = getelementptr inbounds %struct.MDBX_cursor, ptr %4069, i32 0, i32 10
  %4071 = load i64, ptr %27, align 8, !tbaa !24
  %4072 = getelementptr inbounds [32 x i16], ptr %4070, i64 0, i64 %4071
  %4073 = load i16, ptr %4072, align 2, !tbaa !23
  %4074 = add i16 %4073, 1
  store i16 %4074, ptr %4072, align 2, !tbaa !23
  %4075 = load ptr, ptr %31, align 8, !tbaa !5
  %4076 = getelementptr inbounds %struct.MDBX_cursor, ptr %4075, i32 0, i32 9
  %4077 = load i64, ptr %27, align 8, !tbaa !24
  %4078 = getelementptr inbounds [32 x ptr], ptr %4076, i64 0, i64 %4077
  %4079 = load ptr, ptr %4078, align 8, !tbaa !5
  %4080 = load ptr, ptr %7, align 8, !tbaa !5
  %4081 = getelementptr inbounds %struct.MDBX_cursor, ptr %4080, i32 0, i32 9
  %4082 = load i64, ptr %27, align 8, !tbaa !24
  %4083 = getelementptr inbounds [32 x ptr], ptr %4081, i64 0, i64 %4082
  %4084 = load ptr, ptr %4083, align 8, !tbaa !5
  %4085 = icmp ne ptr %4079, %4084
  br i1 %4085, label %4086, label %4129

4086:                                             ; preds = %4059
  %4087 = load ptr, ptr %7, align 8, !tbaa !5
  %4088 = getelementptr inbounds %struct.MDBX_cursor, ptr %4087, i32 0, i32 10
  %4089 = load i64, ptr %27, align 8, !tbaa !24
  %4090 = getelementptr inbounds [32 x i16], ptr %4088, i64 0, i64 %4089
  %4091 = load i16, ptr %4090, align 2, !tbaa !23
  %4092 = zext i16 %4091 to i64
  %4093 = load ptr, ptr %7, align 8, !tbaa !5
  %4094 = getelementptr inbounds %struct.MDBX_cursor, ptr %4093, i32 0, i32 9
  %4095 = load i64, ptr %27, align 8, !tbaa !24
  %4096 = getelementptr inbounds [32 x ptr], ptr %4094, i64 0, i64 %4095
  %4097 = load ptr, ptr %4096, align 8, !tbaa !5
  %4098 = call i64 @page_numkeys(ptr noundef %4097) #12
  %4099 = icmp uge i64 %4092, %4098
  br i1 %4099, label %4100, label %4129

4100:                                             ; preds = %4086
  call void @llvm.lifetime.start.p0(i64 8, ptr %79) #10
  store i64 0, ptr %79, align 8, !tbaa !24
  br label %4101

4101:                                             ; preds = %4125, %4100
  %4102 = load i64, ptr %79, align 8, !tbaa !24
  %4103 = load i64, ptr %27, align 8, !tbaa !24
  %4104 = icmp sle i64 %4102, %4103
  br i1 %4104, label %4106, label %4105

4105:                                             ; preds = %4101
  store i32 237, ptr %23, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %79) #10
  br label %4128

4106:                                             ; preds = %4101
  %4107 = load ptr, ptr %31, align 8, !tbaa !5
  %4108 = getelementptr inbounds %struct.MDBX_cursor, ptr %4107, i32 0, i32 9
  %4109 = load i64, ptr %79, align 8, !tbaa !24
  %4110 = getelementptr inbounds [32 x ptr], ptr %4108, i64 0, i64 %4109
  %4111 = load ptr, ptr %4110, align 8, !tbaa !5
  %4112 = load ptr, ptr %7, align 8, !tbaa !5
  %4113 = getelementptr inbounds %struct.MDBX_cursor, ptr %4112, i32 0, i32 9
  %4114 = load i64, ptr %79, align 8, !tbaa !24
  %4115 = getelementptr inbounds [32 x ptr], ptr %4113, i64 0, i64 %4114
  store ptr %4111, ptr %4115, align 8, !tbaa !5
  %4116 = load ptr, ptr %31, align 8, !tbaa !5
  %4117 = getelementptr inbounds %struct.MDBX_cursor, ptr %4116, i32 0, i32 10
  %4118 = load i64, ptr %79, align 8, !tbaa !24
  %4119 = getelementptr inbounds [32 x i16], ptr %4117, i64 0, i64 %4118
  %4120 = load i16, ptr %4119, align 2, !tbaa !23
  %4121 = load ptr, ptr %7, align 8, !tbaa !5
  %4122 = getelementptr inbounds %struct.MDBX_cursor, ptr %4121, i32 0, i32 10
  %4123 = load i64, ptr %79, align 8, !tbaa !24
  %4124 = getelementptr inbounds [32 x i16], ptr %4122, i64 0, i64 %4123
  store i16 %4120, ptr %4124, align 2, !tbaa !23
  br label %4125

4125:                                             ; preds = %4106
  %4126 = load i64, ptr %79, align 8, !tbaa !24
  %4127 = add nsw i64 %4126, 1
  store i64 %4127, ptr %79, align 8, !tbaa !24
  br label %4101, !llvm.loop !70

4128:                                             ; preds = %4105
  br label %4129

4129:                                             ; preds = %4128, %4086, %4059
  br label %4130

4130:                                             ; preds = %4129, %4055
  br label %4131

4131:                                             ; preds = %4130, %4054
  br label %4132

4132:                                             ; preds = %4131, %3607
  %4133 = load ptr, ptr %20, align 8, !tbaa !5
  %4134 = call i64 @page_numkeys(ptr noundef %4133) #12
  store i64 %4134, ptr %22, align 8, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 8, ptr %80) #10
  %4135 = load ptr, ptr %7, align 8, !tbaa !5
  %4136 = getelementptr inbounds %struct.MDBX_cursor, ptr %4135, i32 0, i32 5
  %4137 = load ptr, ptr %4136, align 8, !tbaa !11
  %4138 = getelementptr inbounds %struct.MDBX_txn, ptr %4137, i32 0, i32 14
  %4139 = load ptr, ptr %4138, align 8, !tbaa !51
  %4140 = load ptr, ptr %7, align 8, !tbaa !5
  %4141 = call i64 @cursor_dbi(ptr noundef %4140) #12
  %4142 = getelementptr inbounds ptr, ptr %4139, i64 %4141
  %4143 = load ptr, ptr %4142, align 8, !tbaa !5
  store ptr %4143, ptr %80, align 8, !tbaa !5
  br label %4144

4144:                                             ; preds = %4494, %4132
  %4145 = load ptr, ptr %80, align 8, !tbaa !5
  %4146 = icmp ne ptr %4145, null
  br i1 %4146, label %4148, label %4147

4147:                                             ; preds = %4144
  store i32 240, ptr %23, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %80) #10
  br label %4498

4148:                                             ; preds = %4144
  call void @llvm.lifetime.start.p0(i64 8, ptr %81) #10
  %4149 = load ptr, ptr %7, align 8, !tbaa !5
  %4150 = getelementptr inbounds %struct.MDBX_cursor, ptr %4149, i32 0, i32 1
  %4151 = getelementptr inbounds %struct.anon.9, ptr %4150, i32 0, i32 0
  %4152 = load i8, ptr %4151, align 4, !tbaa !19
  %4153 = sext i8 %4152 to i32
  %4154 = and i32 %4153, 1
  %4155 = icmp ne i32 %4154, 0
  br i1 %4155, label %4156, label %4161

4156:                                             ; preds = %4148
  %4157 = load ptr, ptr %80, align 8, !tbaa !5
  %4158 = getelementptr inbounds %struct.MDBX_cursor, ptr %4157, i32 0, i32 8
  %4159 = load ptr, ptr %4158, align 8, !tbaa !71
  %4160 = getelementptr inbounds %struct.inner_cursor, ptr %4159, i32 0, i32 0
  br label %4163

4161:                                             ; preds = %4148
  %4162 = load ptr, ptr %80, align 8, !tbaa !5
  br label %4163

4163:                                             ; preds = %4161, %4156
  %4164 = phi ptr [ %4160, %4156 ], [ %4162, %4161 ]
  store ptr %4164, ptr %81, align 8, !tbaa !5
  %4165 = load ptr, ptr %81, align 8, !tbaa !5
  %4166 = call zeroext i1 @is_pointed(ptr noundef %4165) #12
  br i1 %4166, label %4167, label %4171

4167:                                             ; preds = %4163
  %4168 = load ptr, ptr %81, align 8, !tbaa !5
  %4169 = load ptr, ptr %7, align 8, !tbaa !5
  %4170 = icmp eq ptr %4168, %4169
  br i1 %4170, label %4171, label %4172

4171:                                             ; preds = %4167, %4163
  store i32 242, ptr %23, align 4
  br label %4491

4172:                                             ; preds = %4167
  %4173 = load i32, ptr %14, align 4, !tbaa !9
  %4174 = icmp ne i32 %4173, 0
  br i1 %4174, label %4175, label %4245

4175:                                             ; preds = %4172
  %4176 = load ptr, ptr %81, align 8, !tbaa !5
  %4177 = getelementptr inbounds %struct.MDBX_cursor, ptr %4176, i32 0, i32 9
  %4178 = getelementptr inbounds [32 x ptr], ptr %4177, i64 0, i64 0
  %4179 = load ptr, ptr %4178, align 8, !tbaa !5
  %4180 = load ptr, ptr %20, align 8, !tbaa !5
  %4181 = icmp ne ptr %4179, %4180
  br i1 %4181, label %4182, label %4183

4182:                                             ; preds = %4175
  store i32 242, ptr %23, align 4
  br label %4491

4183:                                             ; preds = %4175
  call void @llvm.lifetime.start.p0(i64 8, ptr %82) #10
  %4184 = load i32, ptr %14, align 4, !tbaa !9
  %4185 = sext i32 %4184 to i64
  store i64 %4185, ptr %82, align 8, !tbaa !24
  br label %4186

4186:                                             ; preds = %4211, %4183
  %4187 = load i64, ptr %82, align 8, !tbaa !24
  %4188 = icmp sge i64 %4187, 0
  br i1 %4188, label %4190, label %4189

4189:                                             ; preds = %4186
  store i32 243, ptr %23, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %82) #10
  br label %4214

4190:                                             ; preds = %4186
  %4191 = load ptr, ptr %81, align 8, !tbaa !5
  %4192 = getelementptr inbounds %struct.MDBX_cursor, ptr %4191, i32 0, i32 10
  %4193 = load i64, ptr %82, align 8, !tbaa !24
  %4194 = getelementptr inbounds [32 x i16], ptr %4192, i64 0, i64 %4193
  %4195 = load i16, ptr %4194, align 2, !tbaa !23
  %4196 = load ptr, ptr %81, align 8, !tbaa !5
  %4197 = getelementptr inbounds %struct.MDBX_cursor, ptr %4196, i32 0, i32 10
  %4198 = load i64, ptr %82, align 8, !tbaa !24
  %4199 = add nsw i64 %4198, 1
  %4200 = getelementptr inbounds [32 x i16], ptr %4197, i64 0, i64 %4199
  store i16 %4195, ptr %4200, align 2, !tbaa !23
  %4201 = load ptr, ptr %81, align 8, !tbaa !5
  %4202 = getelementptr inbounds %struct.MDBX_cursor, ptr %4201, i32 0, i32 9
  %4203 = load i64, ptr %82, align 8, !tbaa !24
  %4204 = getelementptr inbounds [32 x ptr], ptr %4202, i64 0, i64 %4203
  %4205 = load ptr, ptr %4204, align 8, !tbaa !5
  %4206 = load ptr, ptr %81, align 8, !tbaa !5
  %4207 = getelementptr inbounds %struct.MDBX_cursor, ptr %4206, i32 0, i32 9
  %4208 = load i64, ptr %82, align 8, !tbaa !24
  %4209 = add nsw i64 %4208, 1
  %4210 = getelementptr inbounds [32 x ptr], ptr %4207, i64 0, i64 %4209
  store ptr %4205, ptr %4210, align 8, !tbaa !5
  br label %4211

4211:                                             ; preds = %4190
  %4212 = load i64, ptr %82, align 8, !tbaa !24
  %4213 = add nsw i64 %4212, -1
  store i64 %4213, ptr %82, align 8, !tbaa !24
  br label %4186, !llvm.loop !72

4214:                                             ; preds = %4189
  %4215 = load ptr, ptr %81, align 8, !tbaa !5
  %4216 = getelementptr inbounds %struct.MDBX_cursor, ptr %4215, i32 0, i32 10
  %4217 = getelementptr inbounds [32 x i16], ptr %4216, i64 0, i64 0
  %4218 = load i16, ptr %4217, align 8, !tbaa !23
  %4219 = zext i16 %4218 to i64
  %4220 = load i64, ptr %22, align 8, !tbaa !24
  %4221 = load i8, ptr %39, align 1, !tbaa !44, !range !45, !noundef !46
  %4222 = trunc i8 %4221 to i1
  %4223 = zext i1 %4222 to i64
  %4224 = add i64 %4220, %4223
  %4225 = icmp uge i64 %4219, %4224
  %4226 = zext i1 %4225 to i32
  %4227 = trunc i32 %4226 to i16
  %4228 = load ptr, ptr %81, align 8, !tbaa !5
  %4229 = getelementptr inbounds %struct.MDBX_cursor, ptr %4228, i32 0, i32 10
  %4230 = getelementptr inbounds [32 x i16], ptr %4229, i64 0, i64 0
  store i16 %4227, ptr %4230, align 8, !tbaa !23
  %4231 = load ptr, ptr %7, align 8, !tbaa !5
  %4232 = getelementptr inbounds %struct.MDBX_cursor, ptr %4231, i32 0, i32 9
  %4233 = getelementptr inbounds [32 x ptr], ptr %4232, i64 0, i64 0
  %4234 = load ptr, ptr %4233, align 8, !tbaa !5
  %4235 = load ptr, ptr %81, align 8, !tbaa !5
  %4236 = getelementptr inbounds %struct.MDBX_cursor, ptr %4235, i32 0, i32 9
  %4237 = getelementptr inbounds [32 x ptr], ptr %4236, i64 0, i64 0
  store ptr %4234, ptr %4237, align 8, !tbaa !5
  %4238 = load ptr, ptr %81, align 8, !tbaa !5
  %4239 = getelementptr inbounds %struct.MDBX_cursor, ptr %4238, i32 0, i32 1
  %4240 = getelementptr inbounds %struct.anon.9, ptr %4239, i32 0, i32 1
  %4241 = load i8, ptr %4240, align 1, !tbaa !19
  %4242 = sext i8 %4241 to i32
  %4243 = add nsw i32 %4242, 1
  %4244 = trunc i32 %4243 to i8
  store i8 %4244, ptr %4240, align 1, !tbaa !19
  br label %4245

4245:                                             ; preds = %4214, %4172
  %4246 = load ptr, ptr %81, align 8, !tbaa !5
  %4247 = getelementptr inbounds %struct.MDBX_cursor, ptr %4246, i32 0, i32 1
  %4248 = getelementptr inbounds %struct.anon.9, ptr %4247, i32 0, i32 1
  %4249 = load i8, ptr %4248, align 1, !tbaa !19
  %4250 = sext i8 %4249 to i32
  %4251 = load ptr, ptr %7, align 8, !tbaa !5
  %4252 = getelementptr inbounds %struct.MDBX_cursor, ptr %4251, i32 0, i32 1
  %4253 = getelementptr inbounds %struct.anon.9, ptr %4252, i32 0, i32 1
  %4254 = load i8, ptr %4253, align 1, !tbaa !19
  %4255 = sext i8 %4254 to i32
  %4256 = icmp sge i32 %4250, %4255
  br i1 %4256, label %4257, label %4418

4257:                                             ; preds = %4245
  %4258 = load ptr, ptr %81, align 8, !tbaa !5
  %4259 = getelementptr inbounds %struct.MDBX_cursor, ptr %4258, i32 0, i32 9
  %4260 = load ptr, ptr %7, align 8, !tbaa !5
  %4261 = getelementptr inbounds %struct.MDBX_cursor, ptr %4260, i32 0, i32 1
  %4262 = getelementptr inbounds %struct.anon.9, ptr %4261, i32 0, i32 1
  %4263 = load i8, ptr %4262, align 1, !tbaa !19
  %4264 = sext i8 %4263 to i64
  %4265 = getelementptr inbounds [32 x ptr], ptr %4259, i64 0, i64 %4264
  %4266 = load ptr, ptr %4265, align 8, !tbaa !5
  %4267 = load ptr, ptr %20, align 8, !tbaa !5
  %4268 = icmp eq ptr %4266, %4267
  br i1 %4268, label %4269, label %4418

4269:                                             ; preds = %4257
  %4270 = load i8, ptr %39, align 1, !tbaa !44, !range !45, !noundef !46
  %4271 = trunc i8 %4270 to i1
  br i1 %4271, label %4418, label %4272

4272:                                             ; preds = %4269
  %4273 = load ptr, ptr %81, align 8, !tbaa !5
  %4274 = getelementptr inbounds %struct.MDBX_cursor, ptr %4273, i32 0, i32 10
  %4275 = load ptr, ptr %7, align 8, !tbaa !5
  %4276 = getelementptr inbounds %struct.MDBX_cursor, ptr %4275, i32 0, i32 1
  %4277 = getelementptr inbounds %struct.anon.9, ptr %4276, i32 0, i32 1
  %4278 = load i8, ptr %4277, align 1, !tbaa !19
  %4279 = sext i8 %4278 to i64
  %4280 = getelementptr inbounds [32 x i16], ptr %4274, i64 0, i64 %4279
  %4281 = load i16, ptr %4280, align 2, !tbaa !23
  %4282 = zext i16 %4281 to i64
  %4283 = load i64, ptr %21, align 8, !tbaa !24
  %4284 = icmp uge i64 %4282, %4283
  br i1 %4284, label %4285, label %4303

4285:                                             ; preds = %4272
  %4286 = load i32, ptr %11, align 4, !tbaa !9
  %4287 = and i32 %4286, 262144
  %4288 = icmp ne i32 %4287, 0
  %4289 = xor i1 %4288, true
  %4290 = zext i1 %4289 to i32
  %4291 = load ptr, ptr %81, align 8, !tbaa !5
  %4292 = getelementptr inbounds %struct.MDBX_cursor, ptr %4291, i32 0, i32 10
  %4293 = load ptr, ptr %7, align 8, !tbaa !5
  %4294 = getelementptr inbounds %struct.MDBX_cursor, ptr %4293, i32 0, i32 1
  %4295 = getelementptr inbounds %struct.anon.9, ptr %4294, i32 0, i32 1
  %4296 = load i8, ptr %4295, align 1, !tbaa !19
  %4297 = sext i8 %4296 to i64
  %4298 = getelementptr inbounds [32 x i16], ptr %4292, i64 0, i64 %4297
  %4299 = load i16, ptr %4298, align 2, !tbaa !23
  %4300 = zext i16 %4299 to i32
  %4301 = add nsw i32 %4300, %4290
  %4302 = trunc i32 %4301 to i16
  store i16 %4302, ptr %4298, align 2, !tbaa !23
  br label %4303

4303:                                             ; preds = %4285, %4272
  %4304 = load ptr, ptr %81, align 8, !tbaa !5
  %4305 = getelementptr inbounds %struct.MDBX_cursor, ptr %4304, i32 0, i32 10
  %4306 = load ptr, ptr %7, align 8, !tbaa !5
  %4307 = getelementptr inbounds %struct.MDBX_cursor, ptr %4306, i32 0, i32 1
  %4308 = getelementptr inbounds %struct.anon.9, ptr %4307, i32 0, i32 1
  %4309 = load i8, ptr %4308, align 1, !tbaa !19
  %4310 = sext i8 %4309 to i64
  %4311 = getelementptr inbounds [32 x i16], ptr %4305, i64 0, i64 %4310
  %4312 = load i16, ptr %4311, align 2, !tbaa !23
  %4313 = zext i16 %4312 to i64
  %4314 = load i64, ptr %22, align 8, !tbaa !24
  %4315 = icmp uge i64 %4313, %4314
  br i1 %4315, label %4316, label %4417

4316:                                             ; preds = %4303
  %4317 = load ptr, ptr %26, align 8, !tbaa !5
  %4318 = load ptr, ptr %81, align 8, !tbaa !5
  %4319 = getelementptr inbounds %struct.MDBX_cursor, ptr %4318, i32 0, i32 9
  %4320 = load ptr, ptr %7, align 8, !tbaa !5
  %4321 = getelementptr inbounds %struct.MDBX_cursor, ptr %4320, i32 0, i32 1
  %4322 = getelementptr inbounds %struct.anon.9, ptr %4321, i32 0, i32 1
  %4323 = load i8, ptr %4322, align 1, !tbaa !19
  %4324 = sext i8 %4323 to i64
  %4325 = getelementptr inbounds [32 x ptr], ptr %4319, i64 0, i64 %4324
  store ptr %4317, ptr %4325, align 8, !tbaa !5
  br label %4326

4326:                                             ; preds = %4316
  %4327 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %4328 = zext i8 %4327 to i32
  %4329 = and i32 %4328, 1
  %4330 = icmp ne i32 %4329, 0
  %4331 = xor i1 %4330, true
  %4332 = xor i1 %4331, true
  %4333 = zext i1 %4332 to i32
  %4334 = sext i32 %4333 to i64
  %4335 = call i64 @llvm.expect.i64(i64 %4334, i64 1)
  %4336 = icmp ne i64 %4335, 0
  br i1 %4336, label %4337, label %4367

4337:                                             ; preds = %4326
  br label %4338

4338:                                             ; preds = %4337
  %4339 = load ptr, ptr %81, align 8, !tbaa !5
  %4340 = getelementptr inbounds %struct.MDBX_cursor, ptr %4339, i32 0, i32 10
  %4341 = load ptr, ptr %7, align 8, !tbaa !5
  %4342 = getelementptr inbounds %struct.MDBX_cursor, ptr %4341, i32 0, i32 1
  %4343 = getelementptr inbounds %struct.anon.9, ptr %4342, i32 0, i32 1
  %4344 = load i8, ptr %4343, align 1, !tbaa !19
  %4345 = sext i8 %4344 to i64
  %4346 = getelementptr inbounds [32 x i16], ptr %4340, i64 0, i64 %4345
  %4347 = load i16, ptr %4346, align 2, !tbaa !23
  %4348 = zext i16 %4347 to i64
  %4349 = load i64, ptr %22, align 8, !tbaa !24
  %4350 = icmp uge i64 %4348, %4349
  %4351 = xor i1 %4350, true
  %4352 = xor i1 %4351, true
  %4353 = xor i1 %4352, true
  %4354 = zext i1 %4353 to i32
  %4355 = sext i32 %4354 to i64
  %4356 = call i64 @llvm.expect.i64(i64 %4355, i64 0)
  %4357 = icmp ne i64 %4356, 0
  br i1 %4357, label %4358, label %4364

4358:                                             ; preds = %4338
  %4359 = load ptr, ptr %7, align 8, !tbaa !5
  %4360 = getelementptr inbounds %struct.MDBX_cursor, ptr %4359, i32 0, i32 5
  %4361 = load ptr, ptr %4360, align 8, !tbaa !11
  %4362 = getelementptr inbounds %struct.MDBX_txn, ptr %4361, i32 0, i32 9
  %4363 = load ptr, ptr %4362, align 8, !tbaa !13
  call void @mdbx_assert_fail(ptr noundef %4363, ptr noundef @.str.102, ptr noundef @__func__.page_split, i32 noundef 1481) #11
  unreachable

4364:                                             ; preds = %4338
  br label %4365

4365:                                             ; preds = %4364
  br label %4366

4366:                                             ; preds = %4365
  br label %4367

4367:                                             ; preds = %4366, %4326
  br label %4368

4368:                                             ; preds = %4367
  br label %4369

4369:                                             ; preds = %4368
  %4370 = load i64, ptr %22, align 8, !tbaa !24
  %4371 = trunc i64 %4370 to i16
  %4372 = zext i16 %4371 to i32
  %4373 = load ptr, ptr %81, align 8, !tbaa !5
  %4374 = getelementptr inbounds %struct.MDBX_cursor, ptr %4373, i32 0, i32 10
  %4375 = load ptr, ptr %7, align 8, !tbaa !5
  %4376 = getelementptr inbounds %struct.MDBX_cursor, ptr %4375, i32 0, i32 1
  %4377 = getelementptr inbounds %struct.anon.9, ptr %4376, i32 0, i32 1
  %4378 = load i8, ptr %4377, align 1, !tbaa !19
  %4379 = sext i8 %4378 to i64
  %4380 = getelementptr inbounds [32 x i16], ptr %4374, i64 0, i64 %4379
  %4381 = load i16, ptr %4380, align 2, !tbaa !23
  %4382 = zext i16 %4381 to i32
  %4383 = sub nsw i32 %4382, %4372
  %4384 = trunc i32 %4383 to i16
  store i16 %4384, ptr %4380, align 2, !tbaa !23
  call void @llvm.lifetime.start.p0(i64 8, ptr %83) #10
  store i64 0, ptr %83, align 8, !tbaa !24
  br label %4385

4385:                                             ; preds = %4413, %4369
  %4386 = load i64, ptr %83, align 8, !tbaa !24
  %4387 = load ptr, ptr %7, align 8, !tbaa !5
  %4388 = getelementptr inbounds %struct.MDBX_cursor, ptr %4387, i32 0, i32 1
  %4389 = getelementptr inbounds %struct.anon.9, ptr %4388, i32 0, i32 1
  %4390 = load i8, ptr %4389, align 1, !tbaa !19
  %4391 = sext i8 %4390 to i64
  %4392 = icmp slt i64 %4386, %4391
  br i1 %4392, label %4394, label %4393

4393:                                             ; preds = %4385
  store i32 250, ptr %23, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %83) #10
  br label %4416

4394:                                             ; preds = %4385
  %4395 = load ptr, ptr %31, align 8, !tbaa !5
  %4396 = getelementptr inbounds %struct.MDBX_cursor, ptr %4395, i32 0, i32 10
  %4397 = load i64, ptr %83, align 8, !tbaa !24
  %4398 = getelementptr inbounds [32 x i16], ptr %4396, i64 0, i64 %4397
  %4399 = load i16, ptr %4398, align 2, !tbaa !23
  %4400 = load ptr, ptr %81, align 8, !tbaa !5
  %4401 = getelementptr inbounds %struct.MDBX_cursor, ptr %4400, i32 0, i32 10
  %4402 = load i64, ptr %83, align 8, !tbaa !24
  %4403 = getelementptr inbounds [32 x i16], ptr %4401, i64 0, i64 %4402
  store i16 %4399, ptr %4403, align 2, !tbaa !23
  %4404 = load ptr, ptr %31, align 8, !tbaa !5
  %4405 = getelementptr inbounds %struct.MDBX_cursor, ptr %4404, i32 0, i32 9
  %4406 = load i64, ptr %83, align 8, !tbaa !24
  %4407 = getelementptr inbounds [32 x ptr], ptr %4405, i64 0, i64 %4406
  %4408 = load ptr, ptr %4407, align 8, !tbaa !5
  %4409 = load ptr, ptr %81, align 8, !tbaa !5
  %4410 = getelementptr inbounds %struct.MDBX_cursor, ptr %4409, i32 0, i32 9
  %4411 = load i64, ptr %83, align 8, !tbaa !24
  %4412 = getelementptr inbounds [32 x ptr], ptr %4410, i64 0, i64 %4411
  store ptr %4408, ptr %4412, align 8, !tbaa !5
  br label %4413

4413:                                             ; preds = %4394
  %4414 = load i64, ptr %83, align 8, !tbaa !24
  %4415 = add nsw i64 %4414, 1
  store i64 %4415, ptr %83, align 8, !tbaa !24
  br label %4385, !llvm.loop !73

4416:                                             ; preds = %4393
  br label %4417

4417:                                             ; preds = %4416, %4303
  br label %4463

4418:                                             ; preds = %4269, %4257, %4245
  %4419 = load i8, ptr %62, align 1, !tbaa !44, !range !45, !noundef !46
  %4420 = trunc i8 %4419 to i1
  br i1 %4420, label %4462, label %4421

4421:                                             ; preds = %4418
  %4422 = load ptr, ptr %81, align 8, !tbaa !5
  %4423 = getelementptr inbounds %struct.MDBX_cursor, ptr %4422, i32 0, i32 1
  %4424 = getelementptr inbounds %struct.anon.9, ptr %4423, i32 0, i32 1
  %4425 = load i8, ptr %4424, align 1, !tbaa !19
  %4426 = sext i8 %4425 to i64
  %4427 = load i64, ptr %27, align 8, !tbaa !24
  %4428 = icmp sge i64 %4426, %4427
  br i1 %4428, label %4429, label %4462

4429:                                             ; preds = %4421
  %4430 = load ptr, ptr %81, align 8, !tbaa !5
  %4431 = getelementptr inbounds %struct.MDBX_cursor, ptr %4430, i32 0, i32 9
  %4432 = load i64, ptr %27, align 8, !tbaa !24
  %4433 = getelementptr inbounds [32 x ptr], ptr %4431, i64 0, i64 %4432
  %4434 = load ptr, ptr %4433, align 8, !tbaa !5
  %4435 = load ptr, ptr %7, align 8, !tbaa !5
  %4436 = getelementptr inbounds %struct.MDBX_cursor, ptr %4435, i32 0, i32 9
  %4437 = load i64, ptr %27, align 8, !tbaa !24
  %4438 = getelementptr inbounds [32 x ptr], ptr %4436, i64 0, i64 %4437
  %4439 = load ptr, ptr %4438, align 8, !tbaa !5
  %4440 = icmp eq ptr %4434, %4439
  br i1 %4440, label %4441, label %4462

4441:                                             ; preds = %4429
  %4442 = load ptr, ptr %81, align 8, !tbaa !5
  %4443 = getelementptr inbounds %struct.MDBX_cursor, ptr %4442, i32 0, i32 10
  %4444 = load i64, ptr %27, align 8, !tbaa !24
  %4445 = getelementptr inbounds [32 x i16], ptr %4443, i64 0, i64 %4444
  %4446 = load i16, ptr %4445, align 2, !tbaa !23
  %4447 = zext i16 %4446 to i32
  %4448 = load ptr, ptr %7, align 8, !tbaa !5
  %4449 = getelementptr inbounds %struct.MDBX_cursor, ptr %4448, i32 0, i32 10
  %4450 = load i64, ptr %27, align 8, !tbaa !24
  %4451 = getelementptr inbounds [32 x i16], ptr %4449, i64 0, i64 %4450
  %4452 = load i16, ptr %4451, align 2, !tbaa !23
  %4453 = zext i16 %4452 to i32
  %4454 = icmp sge i32 %4447, %4453
  br i1 %4454, label %4455, label %4462

4455:                                             ; preds = %4441
  %4456 = load ptr, ptr %81, align 8, !tbaa !5
  %4457 = getelementptr inbounds %struct.MDBX_cursor, ptr %4456, i32 0, i32 10
  %4458 = load i64, ptr %27, align 8, !tbaa !24
  %4459 = getelementptr inbounds [32 x i16], ptr %4457, i64 0, i64 %4458
  %4460 = load i16, ptr %4459, align 2, !tbaa !23
  %4461 = add i16 %4460, 1
  store i16 %4461, ptr %4459, align 2, !tbaa !23
  br label %4462

4462:                                             ; preds = %4455, %4441, %4429, %4421, %4418
  br label %4463

4463:                                             ; preds = %4462, %4417
  %4464 = load ptr, ptr %81, align 8, !tbaa !5
  %4465 = call zeroext i1 @inner_pointed(ptr noundef %4464) #12
  br i1 %4465, label %4466, label %4490

4466:                                             ; preds = %4463
  %4467 = load ptr, ptr %20, align 8, !tbaa !5
  %4468 = call zeroext i1 @is_leaf(ptr noundef %4467) #12
  br i1 %4468, label %4469, label %4490

4469:                                             ; preds = %4466
  %4470 = load ptr, ptr %81, align 8, !tbaa !5
  %4471 = load ptr, ptr %81, align 8, !tbaa !5
  %4472 = getelementptr inbounds %struct.MDBX_cursor, ptr %4471, i32 0, i32 9
  %4473 = load ptr, ptr %7, align 8, !tbaa !5
  %4474 = getelementptr inbounds %struct.MDBX_cursor, ptr %4473, i32 0, i32 1
  %4475 = getelementptr inbounds %struct.anon.9, ptr %4474, i32 0, i32 1
  %4476 = load i8, ptr %4475, align 1, !tbaa !19
  %4477 = sext i8 %4476 to i64
  %4478 = getelementptr inbounds [32 x ptr], ptr %4472, i64 0, i64 %4477
  %4479 = load ptr, ptr %4478, align 8, !tbaa !5
  %4480 = load ptr, ptr %81, align 8, !tbaa !5
  %4481 = getelementptr inbounds %struct.MDBX_cursor, ptr %4480, i32 0, i32 10
  %4482 = load ptr, ptr %7, align 8, !tbaa !5
  %4483 = getelementptr inbounds %struct.MDBX_cursor, ptr %4482, i32 0, i32 1
  %4484 = getelementptr inbounds %struct.anon.9, ptr %4483, i32 0, i32 1
  %4485 = load i8, ptr %4484, align 1, !tbaa !19
  %4486 = sext i8 %4485 to i64
  %4487 = getelementptr inbounds [32 x i16], ptr %4481, i64 0, i64 %4486
  %4488 = load i16, ptr %4487, align 2, !tbaa !23
  %4489 = zext i16 %4488 to i32
  call void @cursor_inner_refresh(ptr noundef %4470, ptr noundef %4479, i32 noundef %4489)
  br label %4490

4490:                                             ; preds = %4469, %4466, %4463
  store i32 0, ptr %23, align 4
  br label %4491

4491:                                             ; preds = %4490, %4182, %4171
  call void @llvm.lifetime.end.p0(i64 8, ptr %81) #10
  %4492 = load i32, ptr %23, align 4
  switch i32 %4492, label %4633 [
    i32 0, label %4493
    i32 242, label %4494
  ]

4493:                                             ; preds = %4491
  br label %4494

4494:                                             ; preds = %4493, %4491
  %4495 = load ptr, ptr %80, align 8, !tbaa !5
  %4496 = getelementptr inbounds %struct.MDBX_cursor, ptr %4495, i32 0, i32 11
  %4497 = load ptr, ptr %4496, align 8, !tbaa !74
  store ptr %4497, ptr %80, align 8, !tbaa !5
  br label %4144, !llvm.loop !75

4498:                                             ; preds = %4147
  br label %4499

4499:                                             ; preds = %4498
  %4500 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 5), align 2, !tbaa !25
  %4501 = zext i8 %4500 to i32
  %4502 = icmp sle i32 6, %4501
  %4503 = xor i1 %4502, true
  %4504 = xor i1 %4503, true
  %4505 = zext i1 %4504 to i32
  %4506 = sext i32 %4505 to i64
  %4507 = call i64 @llvm.expect.i64(i64 %4506, i64 0)
  %4508 = icmp ne i64 %4507, 0
  br i1 %4508, label %4509, label %4520

4509:                                             ; preds = %4499
  %4510 = load ptr, ptr %20, align 8, !tbaa !5
  %4511 = getelementptr inbounds %struct.page, ptr %4510, i32 0, i32 4
  %4512 = load i32, ptr %4511, align 1, !tbaa !9
  %4513 = load ptr, ptr %20, align 8, !tbaa !5
  %4514 = call i64 @page_room(ptr noundef %4513) #12
  %4515 = load ptr, ptr %26, align 8, !tbaa !5
  %4516 = getelementptr inbounds %struct.page, ptr %4515, i32 0, i32 4
  %4517 = load i32, ptr %4516, align 1, !tbaa !9
  %4518 = load ptr, ptr %26, align 8, !tbaa !5
  %4519 = call i64 @page_room(ptr noundef %4518) #12
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef @__func__.page_split, i32 noundef 1495, ptr noundef @.str.103, i32 noundef %4512, i64 noundef %4514, i32 noundef %4517, i64 noundef %4519)
  br label %4520

4520:                                             ; preds = %4509, %4499
  br label %4521

4521:                                             ; preds = %4520
  br label %4522

4522:                                             ; preds = %4521
  br label %4523

4523:                                             ; preds = %4522, %4052, %3603, %3422, %3245, %3188, %2670, %1800, %1784, %528, %342
  %4524 = load ptr, ptr %18, align 8, !tbaa !5
  %4525 = icmp ne ptr %4524, null
  br i1 %4525, label %4526, label %4529

4526:                                             ; preds = %4523
  %4527 = load ptr, ptr %15, align 8, !tbaa !5
  %4528 = load ptr, ptr %18, align 8, !tbaa !5
  call void @page_shadow_release(ptr noundef %4527, ptr noundef %4528, i64 noundef 1)
  br label %4529

4529:                                             ; preds = %4526, %4523
  %4530 = load i32, ptr %13, align 4, !tbaa !9
  %4531 = icmp ne i32 %4530, 0
  %4532 = xor i1 %4531, true
  %4533 = xor i1 %4532, true
  %4534 = zext i1 %4533 to i32
  %4535 = sext i32 %4534 to i64
  %4536 = call i64 @llvm.expect.i64(i64 %4535, i64 0)
  %4537 = icmp ne i64 %4536, 0
  br i1 %4537, label %4538, label %4545

4538:                                             ; preds = %4529
  %4539 = load ptr, ptr %7, align 8, !tbaa !5
  %4540 = getelementptr inbounds %struct.MDBX_cursor, ptr %4539, i32 0, i32 5
  %4541 = load ptr, ptr %4540, align 8, !tbaa !11
  %4542 = getelementptr inbounds %struct.MDBX_txn, ptr %4541, i32 0, i32 1
  %4543 = load i32, ptr %4542, align 4, !tbaa !76
  %4544 = or i32 %4543, 2
  store i32 %4544, ptr %4542, align 4, !tbaa !76
  br label %4609

4545:                                             ; preds = %4529
  %4546 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 4), align 1, !tbaa !20
  %4547 = zext i8 %4546 to i32
  %4548 = and i32 %4547, 2
  %4549 = icmp ne i32 %4548, 0
  %4550 = xor i1 %4549, true
  %4551 = xor i1 %4550, true
  %4552 = zext i1 %4551 to i32
  %4553 = sext i32 %4552 to i64
  %4554 = call i64 @llvm.expect.i64(i64 %4553, i64 0)
  %4555 = icmp ne i64 %4554, 0
  br i1 %4555, label %4556, label %4559

4556:                                             ; preds = %4545
  %4557 = load ptr, ptr %7, align 8, !tbaa !5
  %4558 = call i32 @cursor_validate_updating(ptr noundef %4557)
  store i32 %4558, ptr %13, align 4, !tbaa !9
  br label %4559

4559:                                             ; preds = %4556, %4545
  %4560 = load i32, ptr %11, align 4, !tbaa !9
  %4561 = and i32 %4560, 65536
  %4562 = icmp ne i32 %4561, 0
  %4563 = xor i1 %4562, true
  %4564 = xor i1 %4563, true
  %4565 = zext i1 %4564 to i32
  %4566 = sext i32 %4565 to i64
  %4567 = call i64 @llvm.expect.i64(i64 %4566, i64 0)
  %4568 = icmp ne i64 %4567, 0
  br i1 %4568, label %4569, label %4601

4569:                                             ; preds = %4559
  call void @llvm.lifetime.start.p0(i64 8, ptr %84) #10
  %4570 = load ptr, ptr %7, align 8, !tbaa !5
  %4571 = getelementptr inbounds %struct.MDBX_cursor, ptr %4570, i32 0, i32 9
  %4572 = load ptr, ptr %7, align 8, !tbaa !5
  %4573 = getelementptr inbounds %struct.MDBX_cursor, ptr %4572, i32 0, i32 1
  %4574 = getelementptr inbounds %struct.anon.9, ptr %4573, i32 0, i32 1
  %4575 = load i8, ptr %4574, align 1, !tbaa !19
  %4576 = sext i8 %4575 to i64
  %4577 = getelementptr inbounds [32 x ptr], ptr %4571, i64 0, i64 %4576
  %4578 = load ptr, ptr %4577, align 8, !tbaa !5
  %4579 = load ptr, ptr %7, align 8, !tbaa !5
  %4580 = getelementptr inbounds %struct.MDBX_cursor, ptr %4579, i32 0, i32 10
  %4581 = load ptr, ptr %7, align 8, !tbaa !5
  %4582 = getelementptr inbounds %struct.MDBX_cursor, ptr %4581, i32 0, i32 1
  %4583 = getelementptr inbounds %struct.anon.9, ptr %4582, i32 0, i32 1
  %4584 = load i8, ptr %4583, align 1, !tbaa !19
  %4585 = sext i8 %4584 to i64
  %4586 = getelementptr inbounds [32 x i16], ptr %4580, i64 0, i64 %4585
  %4587 = load i16, ptr %4586, align 2, !tbaa !23
  %4588 = zext i16 %4587 to i64
  %4589 = call ptr @page_node(ptr noundef %4578, i64 noundef %4588) #12
  store ptr %4589, ptr %84, align 8, !tbaa !5
  %4590 = load ptr, ptr %84, align 8, !tbaa !5
  %4591 = call zeroext i8 @node_flags(ptr noundef %4590) #12
  %4592 = zext i8 %4591 to i32
  %4593 = and i32 %4592, 1
  %4594 = icmp ne i32 %4593, 0
  br i1 %4594, label %4600, label %4595

4595:                                             ; preds = %4569
  %4596 = load ptr, ptr %84, align 8, !tbaa !5
  %4597 = call ptr @node_data(ptr noundef %4596) #12
  %4598 = load ptr, ptr %9, align 8, !tbaa !5
  %4599 = getelementptr inbounds %struct.iovec, ptr %4598, i32 0, i32 0
  store ptr %4597, ptr %4599, align 8, !tbaa !47
  br label %4600

4600:                                             ; preds = %4595, %4569
  call void @llvm.lifetime.end.p0(i64 8, ptr %84) #10
  br label %4601

4601:                                             ; preds = %4600, %4559
  %4602 = load ptr, ptr %15, align 8, !tbaa !5
  %4603 = getelementptr inbounds %struct.MDBX_env, ptr %4602, i32 0, i32 7
  %4604 = load ptr, ptr %4603, align 8, !tbaa !77
  %4605 = getelementptr inbounds %struct.shared_lck, ptr %4604, i32 0, i32 9
  %4606 = getelementptr inbounds %struct.pgops, ptr %4605, i32 0, i32 3
  %4607 = load volatile i64, ptr %4606, align 8, !tbaa !19
  %4608 = add i64 %4607, 1
  store volatile i64 %4608, ptr %4606, align 8, !tbaa !19
  br label %4609

4609:                                             ; preds = %4601, %4538
  br label %4610

4610:                                             ; preds = %4609
  %4611 = load i8, ptr getelementptr inbounds (%struct.libmdbx_globals, ptr @globals, i32 0, i32 5), align 2, !tbaa !25
  %4612 = zext i8 %4611 to i32
  %4613 = icmp sle i32 5, %4612
  %4614 = xor i1 %4613, true
  %4615 = xor i1 %4614, true
  %4616 = zext i1 %4615 to i32
  %4617 = sext i32 %4616 to i64
  %4618 = call i64 @llvm.expect.i64(i64 %4617, i64 0)
  %4619 = icmp ne i64 %4618, 0
  br i1 %4619, label %4620, label %4625

4620:                                             ; preds = %4610
  %4621 = load ptr, ptr %20, align 8, !tbaa !5
  %4622 = getelementptr inbounds %struct.page, ptr %4621, i32 0, i32 4
  %4623 = load i32, ptr %4622, align 1, !tbaa !9
  %4624 = load i32, ptr %13, align 4, !tbaa !9
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 5, ptr noundef @__func__.page_split, i32 noundef 1516, ptr noundef @.str.104, i32 noundef %4623, i32 noundef %4624)
  br label %4625

4625:                                             ; preds = %4620, %4610
  br label %4626

4626:                                             ; preds = %4625
  br label %4627

4627:                                             ; preds = %4626
  %4628 = load i32, ptr %13, align 4, !tbaa !9
  store i32 %4628, ptr %6, align 4
  store i32 1, ptr %23, align 4
  br label %4629

4629:                                             ; preds = %4627, %4052, %3603, %3188, %2670, %1784, %528
  call void @llvm.lifetime.end.p0(i64 8, ptr %27) #10
  call void @llvm.lifetime.end.p0(i64 8, ptr %26) #10
  br label %4630

4630:                                             ; preds = %4629, %284
  call void @llvm.lifetime.end.p0(i64 16, ptr %25) #10
  call void @llvm.lifetime.end.p0(i64 8, ptr %24) #10
  br label %4631

4631:                                             ; preds = %4630, %170
  call void @llvm.lifetime.end.p0(i64 8, ptr %22) #10
  call void @llvm.lifetime.end.p0(i64 8, ptr %21) #10
  call void @llvm.lifetime.end.p0(i64 8, ptr %20) #10
  call void @llvm.lifetime.end.p0(i64 510, ptr %19) #10
  call void @llvm.lifetime.end.p0(i64 8, ptr %18) #10
  call void @llvm.lifetime.end.p0(i64 16, ptr %17) #10
  call void @llvm.lifetime.end.p0(i64 16, ptr %16) #10
  call void @llvm.lifetime.end.p0(i64 8, ptr %15) #10
  call void @llvm.lifetime.end.p0(i64 4, ptr %14) #10
  call void @llvm.lifetime.end.p0(i64 4, ptr %13) #10
  call void @llvm.lifetime.end.p0(i64 4, ptr %12) #10
  %4632 = load i32, ptr %6, align 4
  ret i32 %4632

4633:                                             ; preds = %4491, %2141
  unreachable
}

declare ptr @mdbx_dump_val(ptr noundef, ptr noundef, i64 noundef) #4

declare { ptr, i32 } @page_new(ptr noundef, i32 noundef) #4

; 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) #6

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

declare i32 @node_add_branch(ptr noundef, i64 noundef, ptr noundef, i32 noundef) #4

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden { ptr, i64 } @get_key(ptr noundef) #1

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden zeroext i1 @is_dupfix_leaf(ptr noundef) #1

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden { ptr, i64 } @page_dupfix_key(ptr noundef, i64 noundef, i64 noundef) #1

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden i64 @branch_size(ptr noundef, ptr noundef) #1

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden ptr @page_dupfix_ptr(ptr noundef, i64 noundef, i64 noundef) #1

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

declare ptr @page_shadow_alloc(ptr noundef, i64 noundef) #4

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden i64 @leaf_size(ptr noundef, ptr noundef, ptr noundef) #1

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden i64 @node_ks(ptr noalias noundef) #1

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden i64 @node_ds(ptr noalias noundef) #1

; Function Attrs: inlinehint nounwind willreturn memory(none) uwtable
declare hidden i64 @branchless_abs(i64 noundef) #8

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden ptr @node_key(ptr noalias noundef) #1

declare i32 @cursor_sibling_left(ptr noundef) #4

; Function Attrs: nounwind uwtable
declare dso_local i32 @tree_propagate_key(ptr noundef, ptr noundef) #5

declare i32 @node_add_leaf(ptr noundef, i64 noundef, ptr noundef, ptr noundef, i32 noundef) #4

declare i32 @node_add_dupfix(ptr noundef, i64 noundef, ptr noundef) #4

declare i32 @bad_page(ptr noundef, ptr noundef, ...) #4

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden ptr @node_data(ptr noalias noundef) #1

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden zeroext i1 @is_pointed(ptr noundef) #1

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare hidden zeroext i1 @inner_pointed(ptr noundef) #1

; Function Attrs: inlinehint nounwind uwtable
declare hidden void @cursor_inner_refresh(ptr noundef, ptr noundef, i32 noundef) #9

declare void @page_shadow_release(ptr noundef, ptr noundef, i64 noundef) #4

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { inlinehint nounwind willreturn memory(read) uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #2 = { nocallback nofree nosync nounwind willreturn memory(none) }
attributes #3 = { noreturn "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 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #5 = { nounwind 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 #6 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #7 = { nocallback nofree nounwind willreturn memory(argmem: write) }
attributes #8 = { inlinehint nounwind willreturn memory(none) 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 #9 = { 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 #10 = { nounwind }
attributes #11 = { noreturn }
attributes #12 = { nounwind willreturn memory(read) }
attributes #13 = { nounwind willreturn memory(none) }

!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 = !{!"int", !7, i64 0}
!11 = !{!12, !6, i64 16}
!12 = !{!"MDBX_cursor", !10, i64 0, !7, i64 4, !7, i64 6, !7, i64 7, !6, i64 8, !6, i64 16, !6, i64 24, !6, i64 32, !6, i64 40, !7, i64 48, !7, i64 304, !6, i64 368, !6, i64 376}
!13 = !{!14, !6, i64 80}
!14 = !{!"MDBX_txn", !10, i64 0, !10, i64 4, !15, i64 8, !15, i64 16, !6, i64 24, !6, i64 32, !16, i64 40, !15, i64 64, !15, i64 72, !6, i64 80, !6, i64 88, !6, i64 96, !6, i64 104, !6, i64 112, !6, i64 120, !18, i64 128, !6, i64 160, !7, i64 168}
!15 = !{!"long", !7, i64 0}
!16 = !{!"geo", !17, i64 0, !17, i64 2, !10, i64 4, !10, i64 8, !7, i64 12, !7, i64 16}
!17 = !{!"short", !7, i64 0}
!18 = !{!"MDBX_canary", !15, i64 0, !15, i64 8, !15, i64 16, !15, i64 24}
!19 = !{!7, !7, i64 0}
!20 = !{!21, !7, i64 25}
!21 = !{!"libmdbx_globals", !7, i64 0, !10, i64 16, !10, i64 20, !7, i64 24, !7, i64 25, !7, i64 26, !22, i64 27, !10, i64 28, !7, i64 32, !7, i64 40, !15, i64 80, !6, i64 88}
!22 = !{!"_Bool", !7, i64 0}
!23 = !{!17, !17, i64 0}
!24 = !{!15, !15, i64 0}
!25 = !{!21, !7, i64 26}
!26 = !{!27, !15, i64 8}
!27 = !{!"iovec", !6, i64 0, !15, i64 8}
!28 = !{!29, !10, i64 8}
!29 = !{!"page_get_result", !6, i64 0, !10, i64 8}
!30 = !{!29, !6, i64 0}
!31 = !{i64 0, i64 8, !5, i64 8, i64 4, !9}
!32 = !{!12, !6, i64 24}
!33 = !{!34, !17, i64 2}
!34 = !{!"tree", !17, i64 0, !17, i64 2, !10, i64 4, !10, i64 8, !10, i64 12, !10, i64 16, !10, i64 20, !15, i64 24, !15, i64 32, !15, i64 40}
!35 = !{!34, !10, i64 8}
!36 = !{i64 0, i64 8, !5, i64 8, i64 8, !24}
!37 = !{!12, !6, i64 32}
!38 = !{!39, !6, i64 0}
!39 = !{!"clc2", !40, i64 0, !40, i64 24}
!40 = !{!"clc", !6, i64 0, !15, i64 8, !15, i64 16}
!41 = distinct !{!41, !42}
!42 = !{!"llvm.loop.mustprogress"}
!43 = !{!34, !10, i64 4}
!44 = !{!22, !22, i64 0}
!45 = !{i8 0, i8 2}
!46 = !{}
!47 = !{!27, !6, i64 0}
!48 = distinct !{!48, !42}
!49 = distinct !{!49, !42}
!50 = distinct !{!50, !42}
!51 = !{!14, !6, i64 120}
!52 = !{!53, !6, i64 368}
!53 = !{!"cursor_couple", !12, i64 0, !6, i64 384, !54, i64 392}
!54 = !{!"inner_cursor", !12, i64 0, !34, i64 384}
!55 = distinct !{!55, !42}
!56 = distinct !{!56, !42}
!57 = distinct !{!57, !42}
!58 = distinct !{!58, !42}
!59 = distinct !{!59, !42}
!60 = !{!61, !10, i64 8}
!61 = !{!"MDBX_env", !7, i64 0, !10, i64 4, !10, i64 8, !62, i64 16, !10, i64 56, !10, i64 60, !62, i64 64, !6, i64 104, !17, i64 112, !17, i64 114, !17, i64 116, !17, i64 118, !17, i64 120, !17, i64 122, !7, i64 124, !7, i64 128, !7, i64 129, !17, i64 130, !10, i64 132, !10, i64 136, !10, i64 140, !10, i64 144, !63, i64 152, !6, i64 184, !6, i64 192, !6, i64 200, !6, i64 208, !6, i64 216, !10, i64 224, !10, i64 228, !10, i64 232, !6, i64 240, !6, i64 248, !15, i64 256, !64, i64 264, !66, i64 320, !22, i64 360, !6, i64 368, !6, i64 376, !6, i64 384, !67, i64 392, !7, i64 400, !10, i64 440, !10, i64 444, !6, i64 448, !68, i64 456, !7, i64 496, !7, i64 536}
!62 = !{!"osal_mmap", !7, i64 0, !10, i64 8, !15, i64 16, !15, i64 24, !15, i64 32}
!63 = !{!"", !6, i64 0, !6, i64 8, !6, i64 16, !6, i64 24}
!64 = !{!"", !10, i64 0, !10, i64 4, !10, i64 8, !10, i64 12, !15, i64 16, !7, i64 24, !7, i64 25, !7, i64 26, !7, i64 27, !10, i64 28, !10, i64 32, !22, i64 36, !22, i64 37, !22, i64 38, !65, i64 40, !7, i64 48}
!65 = !{!"", !17, i64 0, !17, i64 2, !17, i64 4, !17, i64 6}
!66 = !{!"", !15, i64 0, !15, i64 8, !15, i64 16, !15, i64 24, !15, i64 32}
!67 = !{!"", !15, i64 0}
!68 = !{!"osal_ioring", !10, i64 0, !10, i64 4, !10, i64 8, !6, i64 16, !6, i64 24, !6, i64 32}
!69 = distinct !{!69, !42}
!70 = distinct !{!70, !42}
!71 = !{!12, !6, i64 40}
!72 = distinct !{!72, !42}
!73 = distinct !{!73, !42}
!74 = !{!12, !6, i64 368}
!75 = distinct !{!75, !42}
!76 = !{!14, !10, i64 4}
!77 = !{!61, !6, i64 104}


; 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.libmdbx_globals = type { %union.bin128, i32, i32, i8, i8, i8, i8, i32, %union.logger_union, %union.pthread_mutex_t, i64, ptr }
%union.bin128 = type { %struct.anon.6 }
%struct.anon.6 = type { i64, i64 }
%union.logger_union = type { ptr }
%union.pthread_mutex_t = type { %struct.__pthread_mutex_s }
%struct.__pthread_mutex_s = type { i32, i32, i32, i32, i32, i16, i16, %struct.__pthread_internal_list }
%struct.__pthread_internal_list = type { ptr, ptr }
%struct.iovec = type { ptr, i64 }
%struct.cursor_couple = type { %struct.MDBX_cursor, ptr, %struct.inner_cursor }
%struct.MDBX_cursor = type { i32, %union.anon.8, i8, i8, ptr, ptr, ptr, ptr, ptr, [32 x ptr], [32 x i16], ptr, ptr }
%union.anon.8 = type { i16 }
%struct.inner_cursor = type { %struct.MDBX_cursor, %struct.tree }
%struct.tree = type { i16, i16, i32, i32, i32, i32, i32, i64, i64, i64 }

@globals = external local_unnamed_addr global %struct.libmdbx_globals, align 8
@.str.9 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.10 = external hidden unnamed_addr constant [7 x i8], align 1
@.str.38 = external hidden unnamed_addr constant [30 x i8], align 1
@__func__.page_split = external hidden unnamed_addr constant [11 x i8], align 1
@.str.39 = external hidden unnamed_addr constant [66 x i8], align 1
@.str.40 = external hidden unnamed_addr constant [25 x i8], align 1
@.str.41 = external hidden unnamed_addr constant [22 x i8], align 1
@.str.42 = external hidden unnamed_addr constant [21 x i8], align 1
@.str.43 = external hidden unnamed_addr constant [27 x i8], align 1
@.str.44 = external hidden unnamed_addr constant [26 x i8], align 1
@.str.45 = external hidden unnamed_addr constant [59 x i8], align 1
@.str.46 = external hidden unnamed_addr constant [30 x i8], align 1
@.str.47 = external hidden unnamed_addr constant [36 x i8], align 1
@.str.48 = external hidden unnamed_addr constant [114 x i8], align 1
@.str.49 = external hidden unnamed_addr constant [47 x i8], align 1
@.str.50 = external hidden unnamed_addr constant [43 x i8], align 1
@.str.51 = external hidden unnamed_addr constant [12 x i8], align 1
@.str.52 = external hidden unnamed_addr constant [56 x i8], align 1
@.str.53 = external hidden unnamed_addr constant [54 x i8], align 1
@.str.54 = external hidden unnamed_addr constant [12 x i8], align 1
@.str.55 = external hidden unnamed_addr constant [48 x i8], align 1
@.str.56 = external hidden unnamed_addr constant [32 x i8], align 1
@.str.57 = external hidden unnamed_addr constant [19 x i8], align 1
@.str.58 = external hidden unnamed_addr constant [33 x i8], align 1
@.str.59 = external hidden unnamed_addr constant [37 x i8], align 1
@.str.60 = external hidden unnamed_addr constant [31 x i8], align 1
@.str.61 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.62 = external hidden unnamed_addr constant [43 x i8], align 1
@.str.63 = external hidden unnamed_addr constant [36 x i8], align 1
@.str.64 = external hidden unnamed_addr constant [52 x i8], align 1
@.str.65 = external hidden unnamed_addr constant [47 x i8], align 1
@.str.66 = external hidden unnamed_addr constant [40 x i8], align 1
@.str.67 = external hidden unnamed_addr constant [25 x i8], align 1
@.str.68 = external hidden unnamed_addr constant [60 x i8], align 1
@.str.69 = external hidden unnamed_addr constant [59 x i8], align 1
@.str.70 = external hidden unnamed_addr constant [75 x i8], align 1
@.str.71 = external hidden unnamed_addr constant [11 x i8], align 1
@.str.72 = external hidden unnamed_addr constant [52 x i8], align 1
@.str.73 = external hidden unnamed_addr constant [12 x i8], align 1
@.str.74 = external hidden unnamed_addr constant [23 x i8], align 1
@.str.75 = external hidden unnamed_addr constant [42 x i8], align 1
@.str.76 = external hidden unnamed_addr constant [35 x i8], align 1
@.str.77 = external hidden unnamed_addr constant [11 x i8], align 1
@.str.78 = external hidden unnamed_addr constant [43 x i8], align 1
@.str.79 = external hidden unnamed_addr constant [43 x i8], align 1
@.str.80 = external hidden unnamed_addr constant [40 x i8], align 1
@.str.81 = external hidden unnamed_addr constant [72 x i8], align 1
@.str.82 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.83 = external hidden unnamed_addr constant [85 x i8], align 1
@.str.84 = external hidden unnamed_addr constant [50 x i8], align 1
@.str.85 = external hidden unnamed_addr constant [50 x i8], align 1
@.str.86 = external hidden unnamed_addr constant [45 x i8], align 1
@.str.87 = external hidden unnamed_addr constant [45 x i8], align 1
@.str.88 = external hidden unnamed_addr constant [62 x i8], align 1
@.str.89 = external hidden unnamed_addr constant [55 x i8], align 1
@.str.90 = external hidden unnamed_addr constant [61 x i8], align 1
@.str.91 = external hidden unnamed_addr constant [56 x i8], align 1
@.str.92 = external hidden unnamed_addr constant [40 x i8], align 1
@.str.93 = external hidden unnamed_addr constant [38 x i8], align 1
@.str.94 = external hidden unnamed_addr constant [20 x i8], align 1
@.str.95 = external hidden unnamed_addr constant [59 x i8], align 1
@.str.96 = external hidden unnamed_addr constant [35 x i8], align 1
@.str.97 = external hidden unnamed_addr constant [21 x i8], align 1
@.str.98 = external hidden unnamed_addr constant [10 x i8], align 1
@.str.99 = external hidden unnamed_addr constant [20 x i8], align 1
@.str.100 = external hidden unnamed_addr constant [18 x i8], align 1
@.str.101 = external hidden unnamed_addr constant [36 x i8], align 1
@.str.102 = external hidden unnamed_addr constant [25 x i8], align 1
@.str.103 = external hidden unnamed_addr constant [40 x i8], align 1
@.str.104 = external hidden unnamed_addr constant [18 x i8], align 1

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

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden i64 @page_space(ptr noundef) local_unnamed_addr #1

; Function Attrs: noreturn
declare void @mdbx_assert_fail(ptr noundef, ptr noundef, ptr noundef, i32 noundef) 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) #0

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden i64 @page_numkeys(ptr noundef) local_unnamed_addr #1

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden zeroext i1 @is_leaf(ptr noundef) local_unnamed_addr #1

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden ptr @page_node(ptr noundef, i64 noundef) local_unnamed_addr #1

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden zeroext i8 @node_flags(ptr noalias noundef) local_unnamed_addr #1

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden i32 @node_pgno(ptr noalias noundef) local_unnamed_addr #1

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden zeroext i8 @page_type(ptr noundef) local_unnamed_addr #1

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden i64 @page_room(ptr noundef) local_unnamed_addr #1

declare void @debug_log(i32 noundef, ptr noundef, i32 noundef, ptr noundef, ...) local_unnamed_addr #3

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden i64 @page_used(ptr noundef, ptr noundef) local_unnamed_addr #1

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden i64 @cursor_dbi(ptr noundef) local_unnamed_addr #1

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden zeroext i1 @is_branch(ptr noundef) local_unnamed_addr #1

; Function Attrs: nounwind uwtable
declare hidden ptr @cursor_clone(ptr noundef, ptr noundef) local_unnamed_addr #4

declare i32 @cursor_validate_updating(ptr noundef) local_unnamed_addr #3

; Function Attrs: nounwind uwtable
define dso_local i32 @page_split(ptr noundef %0, ptr noundef %1, ptr noundef %2, i32 noundef %3, i32 noundef %4) local_unnamed_addr #4 {
  %6 = ptrtoint ptr %0 to i64
  %7 = alloca %struct.iovec, align 8
  %8 = alloca %struct.iovec, align 8
  %9 = alloca [510 x i8], align 16
  %10 = alloca %struct.cursor_couple, align 8
  %11 = alloca %struct.iovec, align 8
  %12 = getelementptr inbounds i8, ptr %0, i64 16
  %13 = load ptr, ptr %12, align 8, !tbaa !5
  %14 = getelementptr inbounds i8, ptr %13, i64 80
  %15 = load ptr, ptr %14, align 8, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %7) #10
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %8) #10
  call void @llvm.lifetime.start.p0(i64 510, ptr nonnull %9) #10
  %16 = getelementptr inbounds i8, ptr %0, i64 48
  %17 = getelementptr inbounds i8, ptr %0, i64 4
  %18 = getelementptr inbounds i8, ptr %0, i64 5
  %19 = load i8, ptr %18, align 1, !tbaa !17
  %20 = sext i8 %19 to i64
  %21 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %20
  %22 = load ptr, ptr %21, align 8, !tbaa !18
  %23 = ptrtoint ptr %22 to i64
  %24 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %25 = and i8 %24, 1
  %.not = icmp eq i8 %25, 0
  br i1 %.not, label %31, label %26, !prof !22

26:                                               ; preds = %5
  %27 = getelementptr inbounds i8, ptr %22, i64 10
  %28 = load i16, ptr %27, align 1, !tbaa !23
  %29 = and i16 %28, -8232
  %.not1003 = icmp eq i16 %29, 0
  br i1 %.not1003, label %31, label %30, !prof !24

30:                                               ; preds = %26
  tail call void @mdbx_assert_fail(ptr noundef %15, ptr noundef nonnull @.str.38, ptr noundef nonnull @__func__.page_split, i32 noundef 945) #11
  unreachable

31:                                               ; preds = %26, %5
  %32 = getelementptr inbounds i8, ptr %0, i64 304
  %33 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %20
  %34 = load i16, ptr %33, align 2, !tbaa !23
  %35 = zext i16 %34 to i64
  %36 = tail call i64 @page_numkeys(ptr noundef %22) #12
  %37 = and i8 %24, 2
  %.not1004 = icmp eq i8 %37, 0
  br i1 %.not1004, label %40, label %38, !prof !24

38:                                               ; preds = %31
  %39 = tail call i32 @cursor_validate_updating(ptr noundef nonnull %0) #10
  %.not1005 = icmp eq i32 %39, 0
  br i1 %.not1005, label %40, label %1494, !prof !24

40:                                               ; preds = %38, %31
  %41 = getelementptr inbounds i8, ptr %22, i64 10
  %42 = load i16, ptr %41, align 1, !tbaa !23
  %43 = and i16 %42, 1
  %narrow = add nuw nsw i16 %43, 1
  %44 = zext nneg i16 %narrow to i64
  %45 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 26), align 2, !tbaa !25
  %46 = icmp ugt i8 %45, 4
  br i1 %46, label %47, label %65, !prof !22

47:                                               ; preds = %40
  %48 = tail call zeroext i1 @is_leaf(ptr noundef nonnull %22) #12
  %49 = select i1 %48, ptr @.str.9, ptr @.str.10
  %50 = getelementptr inbounds i8, ptr %22, i64 16
  %51 = load i32, ptr %50, align 1, !tbaa !26
  %52 = getelementptr inbounds i8, ptr %1, i64 8
  %53 = load i64, ptr %52, align 8, !tbaa !27
  %.not1006 = icmp eq ptr %2, null
  br i1 %.not1006, label %57, label %54

54:                                               ; preds = %47
  %55 = getelementptr inbounds i8, ptr %2, i64 8
  %56 = load i64, ptr %55, align 8, !tbaa !27
  br label %57

57:                                               ; preds = %47, %54
  %58 = phi i64 [ %56, %54 ], [ 0, %47 ]
  %59 = call ptr @mdbx_dump_val(ptr noundef nonnull %1, ptr noundef nonnull %9, i64 noundef 255) #10
  %60 = load i8, ptr %18, align 1, !tbaa !17
  %61 = sext i8 %60 to i64
  %62 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %61
  %63 = load i16, ptr %62, align 2, !tbaa !23
  %64 = zext i16 %63 to i32
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 5, ptr noundef nonnull @__func__.page_split, i32 noundef 958, ptr noundef nonnull @.str.39, ptr noundef nonnull %49, i32 noundef %51, i64 noundef %53, i64 noundef %58, ptr noundef %59, i32 noundef %64, i64 noundef %36) #10
  br label %65

65:                                               ; preds = %40, %57
  %66 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %67 = and i8 %66, 1
  %.not1007 = icmp eq i8 %67, 0
  br i1 %.not1007, label %75, label %68, !prof !22

68:                                               ; preds = %65
  %69 = add i64 %36, 1
  %70 = shl nuw nsw i64 %44, 1
  %.not1008 = icmp ult i64 %69, %70
  br i1 %.not1008, label %71, label %75, !prof !22

71:                                               ; preds = %68
  %72 = load ptr, ptr %12, align 8, !tbaa !5
  %73 = getelementptr inbounds i8, ptr %72, i64 80
  %74 = load ptr, ptr %73, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %74, ptr noundef nonnull @.str.40, ptr noundef nonnull @__func__.page_split, i32 noundef 959) #11
  unreachable

75:                                               ; preds = %68, %65
  %76 = load i16, ptr %41, align 1, !tbaa !23
  %77 = zext i16 %76 to i32
  %78 = call { ptr, i32 } @page_new(ptr noundef nonnull %0, i32 noundef %77) #10
  %79 = extractvalue { ptr, i32 } %78, 0
  %80 = extractvalue { ptr, i32 } %78, 1
  %.not1009 = icmp eq i32 %80, 0
  br i1 %.not1009, label %81, label %1494, !prof !24

81:                                               ; preds = %75
  %82 = getelementptr inbounds i8, ptr %22, i64 8
  %83 = load i16, ptr %82, align 1, !tbaa !23
  %84 = getelementptr inbounds i8, ptr %79, i64 8
  store i16 %83, ptr %84, align 1, !tbaa !23
  %85 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 26), align 2, !tbaa !25
  %86 = icmp ugt i8 %85, 4
  br i1 %86, label %87, label %90, !prof !22

87:                                               ; preds = %81
  %88 = getelementptr inbounds i8, ptr %79, i64 16
  %89 = load i32, ptr %88, align 1, !tbaa !26
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 5, ptr noundef nonnull @__func__.page_split, i32 noundef 967, ptr noundef nonnull @.str.41, i32 noundef %89) #10
  br label %90

90:                                               ; preds = %87, %81
  %91 = load i8, ptr %18, align 1, !tbaa !17
  %92 = sext i8 %91 to i64
  %93 = add nsw i64 %92, -1
  %94 = icmp eq i8 %91, 0
  br i1 %94, label %95, label %145

95:                                               ; preds = %90
  %96 = call { ptr, i32 } @page_new(ptr noundef nonnull %0, i32 noundef 1) #10
  %97 = extractvalue { ptr, i32 } %96, 0
  %98 = extractvalue { ptr, i32 } %96, 1
  %.not1010 = icmp eq i32 %98, 0
  br i1 %.not1010, label %99, label %.thread1253, !prof !24

99:                                               ; preds = %95
  %100 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %101 = and i8 %100, 1
  %.not1011 = icmp eq i8 %101, 0
  %.phi.trans.insert = getelementptr inbounds i8, ptr %0, i64 24
  %.pre = load ptr, ptr %.phi.trans.insert, align 8, !tbaa !29
  br i1 %.not1011, label %._crit_edge1343, label %102, !prof !22

102:                                              ; preds = %99
  %103 = getelementptr inbounds i8, ptr %.pre, i64 2
  %104 = load i16, ptr %103, align 2, !tbaa !30
  %.not1012 = icmp eq i16 %104, 0
  br i1 %.not1012, label %105, label %._crit_edge1343, !prof !22

105:                                              ; preds = %102
  %106 = load ptr, ptr %12, align 8, !tbaa !5
  %107 = getelementptr inbounds i8, ptr %106, i64 80
  %108 = load ptr, ptr %107, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %108, ptr noundef nonnull @.str.42, ptr noundef nonnull @__func__.page_split, i32 noundef 981) #11
  unreachable

._crit_edge1343:                                  ; preds = %99, %102
  %109 = getelementptr inbounds i8, ptr %0, i64 72
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(232) %109, i8 0, i64 232, i1 false)
  %110 = getelementptr inbounds i8, ptr %0, i64 310
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 2 dereferenceable(58) %110, i8 -1, i64 58, i1 false)
  %111 = getelementptr inbounds i8, ptr %0, i64 56
  %112 = getelementptr inbounds i8, ptr %0, i64 306
  %113 = load <2 x ptr>, ptr %16, align 8, !tbaa !18
  store <2 x ptr> %113, ptr %111, align 8, !tbaa !18
  %114 = load <2 x i16>, ptr %32, align 8, !tbaa !23
  store <2 x i16> %114, ptr %112, align 2, !tbaa !23
  store ptr %97, ptr %16, align 8, !tbaa !18
  store i16 0, ptr %32, align 8, !tbaa !23
  %115 = getelementptr inbounds i8, ptr %97, i64 16
  %116 = load i32, ptr %115, align 1, !tbaa !26
  %117 = getelementptr inbounds i8, ptr %0, i64 24
  %118 = getelementptr inbounds i8, ptr %.pre, i64 8
  store i32 %116, ptr %118, align 4, !tbaa !32
  %119 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 26), align 2, !tbaa !25
  %120 = icmp ugt i8 %119, 4
  br i1 %120, label %121, label %123, !prof !22

121:                                              ; preds = %._crit_edge1343
  %122 = load i32, ptr %115, align 1, !tbaa !26
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 5, ptr noundef nonnull @__func__.page_split, i32 noundef 993, ptr noundef nonnull @.str.43, i32 noundef %122) #10
  %.pre1344 = load ptr, ptr %117, align 8, !tbaa !29
  br label %123

123:                                              ; preds = %121, %._crit_edge1343
  %124 = phi ptr [ %.pre1344, %121 ], [ %.pre, %._crit_edge1343 ]
  %125 = getelementptr inbounds i8, ptr %124, i64 2
  %126 = load i16, ptr %125, align 2, !tbaa !30
  %127 = add i16 %126, 1
  store i16 %127, ptr %125, align 2, !tbaa !30
  %128 = getelementptr inbounds i8, ptr %22, i64 16
  %129 = load i32, ptr %128, align 1, !tbaa !26
  %130 = call i32 @node_add_branch(ptr noundef nonnull %0, i64 noundef 0, ptr noundef null, i32 noundef %129) #10
  %.not1013 = icmp eq i32 %130, 0
  br i1 %.not1013, label %140, label %131, !prof !24

131:                                              ; preds = %123
  %132 = load ptr, ptr %111, align 8, !tbaa !18
  store ptr %132, ptr %16, align 8, !tbaa !18
  %133 = load i16, ptr %112, align 2, !tbaa !23
  store i16 %133, ptr %32, align 8, !tbaa !23
  %134 = load i32, ptr %128, align 1, !tbaa !26
  %135 = load ptr, ptr %117, align 8, !tbaa !29
  %136 = getelementptr inbounds i8, ptr %135, i64 8
  store i32 %134, ptr %136, align 4, !tbaa !32
  %137 = getelementptr inbounds i8, ptr %135, i64 2
  %138 = load i16, ptr %137, align 2, !tbaa !30
  %139 = add i16 %138, -1
  store i16 %139, ptr %137, align 2, !tbaa !30
  br label %.thread1253

140:                                              ; preds = %123
  store i8 1, ptr %18, align 1, !tbaa !17
  %141 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %142 = and i8 %141, 2
  %.not1014 = icmp eq i8 %142, 0
  br i1 %.not1014, label %153, label %143, !prof !24

143:                                              ; preds = %140
  %144 = call i32 @cursor_validate_updating(ptr noundef nonnull %0) #10
  %.not1015 = icmp eq i32 %144, 0
  br i1 %.not1015, label %153, label %.thread1253, !prof !24

145:                                              ; preds = %90
  %146 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 26), align 2, !tbaa !25
  %147 = icmp ugt i8 %146, 4
  br i1 %147, label %148, label %153, !prof !22

148:                                              ; preds = %145
  %149 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %93
  %150 = load ptr, ptr %149, align 8, !tbaa !18
  %151 = getelementptr inbounds i8, ptr %150, i64 16
  %152 = load i32, ptr %151, align 1, !tbaa !26
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 5, ptr noundef nonnull @__func__.page_split, i32 noundef 1014, ptr noundef nonnull @.str.44, i32 noundef %152) #10
  br label %153

153:                                              ; preds = %143, %140, %145, %148
  %.1915 = phi i64 [ %93, %148 ], [ %93, %145 ], [ 0, %140 ], [ 0, %143 ]
  %.0898.shrunk = phi i16 [ 0, %148 ], [ 0, %145 ], [ %126, %140 ], [ %126, %143 ]
  %.0898 = zext i16 %.0898.shrunk to i32
  %154 = call ptr @cursor_clone(ptr noundef nonnull %0, ptr noundef nonnull %10)
  %155 = ptrtoint ptr %154 to i64
  %156 = getelementptr inbounds i8, ptr %154, i64 48
  %157 = getelementptr inbounds i8, ptr %154, i64 5
  %158 = load i8, ptr %157, align 1, !tbaa !17
  %159 = sext i8 %158 to i64
  %160 = getelementptr inbounds [32 x ptr], ptr %156, i64 0, i64 %159
  store ptr %79, ptr %160, align 8, !tbaa !18
  %161 = getelementptr inbounds i8, ptr %154, i64 304
  %162 = load i8, ptr %157, align 1, !tbaa !17
  %163 = sext i8 %162 to i64
  %164 = getelementptr inbounds [32 x i16], ptr %161, i64 0, i64 %163
  store i16 0, ptr %164, align 2, !tbaa !23
  %165 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %.1915
  %166 = load i16, ptr %165, align 2, !tbaa !23
  %167 = add i16 %166, 1
  %168 = getelementptr inbounds [32 x i16], ptr %161, i64 0, i64 %.1915
  store i16 %167, ptr %168, align 2, !tbaa !23
  %169 = icmp ugt i64 %36, %35
  %170 = add i64 %36, 1
  %171 = lshr i64 %170, 1
  %172 = sub i64 %36, %44
  %173 = add i64 %172, 1
  %174 = select i1 %169, i64 %171, i64 %173
  %175 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %176 = and i8 %175, 1
  %.not1016 = icmp eq i8 %176, 0
  br i1 %.not1016, label %.thread1176, label %177, !prof !22

177:                                              ; preds = %153
  %.not1017 = icmp uge i64 %174, %44
  %178 = icmp ule i64 %174, %173
  %179 = select i1 %.not1017, i1 %178, i1 false
  br i1 %179, label %181, label %180, !prof !24

180:                                              ; preds = %177
  call void @mdbx_assert_fail(ptr noundef %15, ptr noundef nonnull @.str.45, ptr noundef nonnull @__func__.page_split, i32 noundef 1025) #11
  unreachable

181:                                              ; preds = %177
  %182 = call zeroext i1 @is_branch(ptr noundef nonnull %22) #12
  %183 = icmp eq i16 %34, 0
  %.not1020 = select i1 %182, i1 %183, i1 false
  br i1 %.not1020, label %184, label %.thread1176, !prof !22

184:                                              ; preds = %181
  %185 = load ptr, ptr %12, align 8, !tbaa !5
  %186 = getelementptr inbounds i8, ptr %185, i64 80
  %187 = load ptr, ptr %186, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %187, ptr noundef nonnull @.str.46, ptr noundef nonnull @__func__.page_split, i32 noundef 1027) #11
  unreachable

.thread1176:                                      ; preds = %153, %181
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %11, i8 0, i64 16, i1 false)
  %.not1021 = icmp ugt i16 %34, %43
  br i1 %.not1021, label %.thread1180, label %188, !prof !24

188:                                              ; preds = %.thread1176
  %189 = icmp eq i16 %34, 0
  %190 = and i32 %4, 262144
  %.not1022 = icmp eq i32 %190, 0
  %or.cond = and i1 %.not1022, %189
  br i1 %or.cond, label %.preheader1276, label %.thread1180

.preheader1276:                                   ; preds = %188
  %191 = load i8, ptr %18, align 1, !tbaa !17
  %192 = sext i8 %191 to i64
  %193 = icmp sgt i8 %191, 0
  br i1 %193, label %.lr.ph, label %.thread1178

.lr.ph:                                           ; preds = %.preheader1276, %209
  %.09261282 = phi i64 [ %210, %209 ], [ 0, %.preheader1276 ]
  %194 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %.09261282
  %195 = load i16, ptr %194, align 2, !tbaa !23
  %.not1023 = icmp eq i16 %195, 0
  br i1 %.not1023, label %209, label %196

196:                                              ; preds = %.lr.ph
  %197 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %.09261282
  %198 = load ptr, ptr %197, align 8, !tbaa !18
  %199 = zext i16 %195 to i64
  %200 = call ptr @page_node(ptr noundef %198, i64 noundef %199) #12
  %201 = call { ptr, i64 } @get_key(ptr noundef %200) #12
  %202 = extractvalue { ptr, i64 } %201, 0
  %203 = extractvalue { ptr, i64 } %201, 1
  store ptr %202, ptr %11, align 8, !tbaa !18
  %.sroa.4234.0..sroa_idx = getelementptr inbounds i8, ptr %11, i64 8
  store i64 %203, ptr %.sroa.4234.0..sroa_idx, align 8, !tbaa !33
  %204 = getelementptr inbounds i8, ptr %0, i64 32
  %205 = load ptr, ptr %204, align 8, !tbaa !34
  %206 = load ptr, ptr %205, align 8, !tbaa !35
  %207 = call i32 %206(ptr noundef %1, ptr noundef nonnull %11) #10
  %208 = icmp slt i32 %207, 0
  br i1 %208, label %.thread1178, label %242

209:                                              ; preds = %.lr.ph
  %210 = add nuw nsw i64 %.09261282, 1
  %exitcond.not = icmp eq i64 %210, %192
  br i1 %exitcond.not, label %.thread1178, label %.lr.ph, !llvm.loop !38

.thread1178:                                      ; preds = %209, %.preheader1276, %196
  %211 = call zeroext i1 @is_dupfix_leaf(ptr noundef %22) #12
  br i1 %211, label %212, label %219

212:                                              ; preds = %.thread1178
  %213 = getelementptr inbounds i8, ptr %0, i64 24
  %214 = load ptr, ptr %213, align 8, !tbaa !29
  %215 = getelementptr inbounds i8, ptr %214, i64 4
  %216 = load i32, ptr %215, align 4, !tbaa !40
  %217 = zext i32 %216 to i64
  %218 = call { ptr, i64 } @page_dupfix_key(ptr noundef %22, i64 noundef 0, i64 noundef %217) #12
  br label %222

219:                                              ; preds = %.thread1178
  %220 = call ptr @page_node(ptr noundef %22, i64 noundef 0) #12
  %221 = call { ptr, i64 } @get_key(ptr noundef %220) #12
  br label %222

222:                                              ; preds = %212, %219
  %.pn = phi { ptr, i64 } [ %218, %212 ], [ %221, %219 ]
  %.sink = extractvalue { ptr, i64 } %.pn, 1
  %.sink1342 = extractvalue { ptr, i64 } %.pn, 0
  store ptr %.sink1342, ptr %11, align 8
  %223 = getelementptr inbounds i8, ptr %11, i64 8
  store i64 %.sink, ptr %223, align 8
  %224 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %225 = and i8 %224, 1
  %.not1024 = icmp eq i8 %225, 0
  br i1 %.not1024, label %236, label %226, !prof !22

226:                                              ; preds = %222
  %227 = getelementptr inbounds i8, ptr %0, i64 32
  %228 = load ptr, ptr %227, align 8, !tbaa !34
  %229 = load ptr, ptr %228, align 8, !tbaa !35
  %230 = call i32 %229(ptr noundef %1, ptr noundef nonnull %11) #10
  %231 = icmp sgt i32 %230, -1
  br i1 %231, label %232, label %236, !prof !22

232:                                              ; preds = %226
  %233 = load ptr, ptr %12, align 8, !tbaa !5
  %234 = getelementptr inbounds i8, ptr %233, i64 80
  %235 = load ptr, ptr %234, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %235, ptr noundef nonnull @.str.47, ptr noundef nonnull @__func__.page_split, i32 noundef 1050) #11
  unreachable

236:                                              ; preds = %226, %222
  %237 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %.1915
  %238 = load ptr, ptr %237, align 8, !tbaa !18
  %239 = call i64 @page_room(ptr noundef %238) #12
  %240 = call i64 @branch_size(ptr noundef %15, ptr noundef nonnull %11) #12
  %241 = icmp ult i64 %239, %240
  %spec.select1136 = select i1 %241, i64 %44, i64 0
  br label %242

242:                                              ; preds = %196, %236
  %.2921 = phi i64 [ %spec.select1136, %236 ], [ %44, %196 ]
  %.not1025 = icmp ne i16 %.0898.shrunk, 0
  %243 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 26), align 2
  %244 = icmp ugt i8 %243, 5
  %or.cond1259 = select i1 %.not1025, i1 %244, i1 false
  br i1 %or.cond1259, label %245, label %.thread1180, !prof !41

245:                                              ; preds = %242
  %246 = load i8, ptr %18, align 1, !tbaa !17
  %247 = sext i8 %246 to i32
  %248 = call ptr @mdbx_dump_val(ptr noundef nonnull %11, ptr noundef nonnull %9, i64 noundef 255) #10
  %249 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %.1915
  %250 = load ptr, ptr %249, align 8, !tbaa !18
  %251 = call i64 @page_room(ptr noundef %250) #12
  %252 = call i64 @branch_size(ptr noundef %15, ptr noundef nonnull %11) #12
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef nonnull @__func__.page_split, i32 noundef 1059, ptr noundef nonnull @.str.48, i32 noundef %.0898, i32 noundef %247, i64 noundef %.1915, i64 noundef %.2921, i64 noundef %44, ptr noundef %248, i64 noundef %251, i64 noundef %252) #10
  %.pr = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 26), align 2, !tbaa !25
  %253 = icmp ugt i8 %.pr, 5
  br i1 %253, label %254, label %.thread1180, !prof !42

254:                                              ; preds = %245
  %255 = call ptr @mdbx_dump_val(ptr noundef %1, ptr noundef nonnull %9, i64 noundef 255) #10
  %256 = getelementptr inbounds i8, ptr %9, i64 255
  %257 = call ptr @mdbx_dump_val(ptr noundef %2, ptr noundef nonnull %256, i64 noundef 255) #10
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef nonnull @__func__.page_split, i32 noundef 1060, ptr noundef nonnull @.str.49, ptr noundef %255, ptr noundef %257, i64 noundef 0) #10
  br label %.thread1180

.thread1180:                                      ; preds = %188, %245, %254, %242, %.thread1176
  %.3922 = phi i64 [ %.2921, %254 ], [ %.2921, %245 ], [ %.2921, %242 ], [ %44, %188 ], [ %174, %.thread1176 ]
  %258 = icmp eq i64 %.3922, %36
  %259 = icmp eq i64 %.3922, 0
  br i1 %258, label %260, label %276, !prof !22

260:                                              ; preds = %.thread1180
  %261 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 26), align 2, !tbaa !25
  %262 = icmp ugt i8 %261, 5
  br i1 %262, label %263, label %264, !prof !22

263:                                              ; preds = %260
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef nonnull @__func__.page_split, i32 noundef 1069, ptr noundef nonnull @.str.50, ptr noundef nonnull @.str.51) #10
  br label %264

264:                                              ; preds = %260, %263
  %265 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %266 = and i8 %265, 1
  %.not1067 = icmp eq i8 %266, 0
  br i1 %.not1067, label %275, label %267, !prof !22

267:                                              ; preds = %264
  %268 = icmp eq i64 %36, %35
  %269 = icmp eq i16 %43, 0
  %270 = select i1 %268, i1 %269, i1 false, !prof !24
  br i1 %270, label %275, label %271, !prof !24

271:                                              ; preds = %267
  %272 = load ptr, ptr %12, align 8, !tbaa !5
  %273 = getelementptr inbounds i8, ptr %272, i64 80
  %274 = load ptr, ptr %273, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %274, ptr noundef nonnull @.str.52, ptr noundef nonnull @__func__.page_split, i32 noundef 1070) #11
  unreachable

275:                                              ; preds = %267, %264
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %11, ptr noundef nonnull align 8 dereferenceable(16) %1, i64 16, i1 false), !tbaa.struct !43
  br label %thread-pre-split

276:                                              ; preds = %.thread1180
  br i1 %259, label %277, label %296, !prof !22

277:                                              ; preds = %276
  %278 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 26), align 2, !tbaa !25
  %279 = icmp ugt i8 %278, 5
  br i1 %279, label %280, label %281, !prof !22

280:                                              ; preds = %277
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef nonnull @__func__.page_split, i32 noundef 1074, ptr noundef nonnull @.str.53, ptr noundef nonnull @.str.54) #10
  br label %281

281:                                              ; preds = %277, %280
  %282 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %283 = and i8 %282, 1
  %.not1066 = icmp eq i8 %283, 0
  br i1 %.not1066, label %291, label %284, !prof !22

284:                                              ; preds = %281
  %285 = icmp eq i16 %34, 0
  %286 = icmp eq i16 %43, 0
  %spec.select1137 = select i1 %285, i1 %286, i1 false, !prof !44
  br i1 %spec.select1137, label %291, label %287, !prof !24

287:                                              ; preds = %284
  %288 = load ptr, ptr %12, align 8, !tbaa !5
  %289 = getelementptr inbounds i8, ptr %288, i64 80
  %290 = load ptr, ptr %289, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %290, ptr noundef nonnull @.str.55, ptr noundef nonnull @__func__.page_split, i32 noundef 1075) #11
  unreachable

291:                                              ; preds = %281, %284
  %292 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 26), align 2, !tbaa !25
  %293 = icmp ugt i8 %292, 5
  br i1 %293, label %294, label %656, !prof !22

294:                                              ; preds = %291
  %295 = call ptr @mdbx_dump_val(ptr noundef nonnull %11, ptr noundef nonnull %9, i64 noundef 255) #10
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef nonnull @__func__.page_split, i32 noundef 1076, ptr noundef nonnull @.str.56, ptr noundef %295) #10
  br label %thread-pre-split

296:                                              ; preds = %276
  %297 = call zeroext i1 @is_dupfix_leaf(ptr noundef %79) #12
  br i1 %297, label %298, label %486

298:                                              ; preds = %296
  %299 = load i8, ptr %18, align 1, !tbaa !17
  %300 = sext i8 %299 to i64
  %301 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %300
  %302 = load i16, ptr %301, align 2, !tbaa !23
  %303 = zext i16 %302 to i64
  %304 = sub nsw i64 %303, %.3922
  %305 = getelementptr inbounds i8, ptr %0, i64 24
  %306 = load ptr, ptr %305, align 8, !tbaa !29
  %307 = getelementptr inbounds i8, ptr %306, i64 4
  %308 = load i32, ptr %307, align 4, !tbaa !40
  %309 = zext i32 %308 to i64
  %310 = call ptr @page_dupfix_ptr(ptr noundef %22, i64 noundef %.3922, i64 noundef %309) #12
  %311 = sub i64 %36, %.3922
  %312 = mul i64 %311, %309
  %313 = shl i64 %311, 1
  %314 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %315 = and i8 %314, 1
  %.not1044 = icmp ne i8 %315, 0
  %.phi.trans.insert1349 = getelementptr inbounds i8, ptr %22, i64 12
  %.pre1350 = load i16, ptr %.phi.trans.insert1349, align 1, !tbaa !17
  %316 = zext i16 %.pre1350 to i64
  %.not1045 = icmp ugt i64 %313, %316
  %or.cond1402 = select i1 %.not1044, i1 %.not1045, i1 false
  br i1 %or.cond1402, label %317, label %._crit_edge1348, !prof !45

317:                                              ; preds = %298
  %318 = load ptr, ptr %12, align 8, !tbaa !5
  %319 = getelementptr inbounds i8, ptr %318, i64 80
  %320 = load ptr, ptr %319, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %320, ptr noundef nonnull @.str.57, ptr noundef nonnull @__func__.page_split, i32 noundef 1085) #11
  unreachable

._crit_edge1348:                                  ; preds = %298
  %321 = trunc i64 %313 to i16
  %322 = getelementptr inbounds i8, ptr %22, i64 12
  %323 = sub i16 %.pre1350, %321
  store i16 %323, ptr %322, align 1, !tbaa !17
  %324 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %325 = and i8 %324, 1
  %.not1046 = icmp ne i8 %325, 0
  %.phi.trans.insert1352 = getelementptr inbounds i8, ptr %79, i64 12
  %.pre1353 = load i16, ptr %.phi.trans.insert1352, align 1, !tbaa !17
  %326 = zext i16 %.pre1353 to i64
  %327 = add i64 %313, %326
  %328 = icmp ugt i64 %327, 65535
  %or.cond1405 = select i1 %.not1046, i1 %328, i1 false
  br i1 %or.cond1405, label %329, label %._crit_edge1351, !prof !45

329:                                              ; preds = %._crit_edge1348
  %330 = load ptr, ptr %12, align 8, !tbaa !5
  %331 = getelementptr inbounds i8, ptr %330, i64 80
  %332 = load ptr, ptr %331, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %332, ptr noundef nonnull @.str.58, ptr noundef nonnull @__func__.page_split, i32 noundef 1087) #11
  unreachable

._crit_edge1351:                                  ; preds = %._crit_edge1348
  %333 = getelementptr inbounds i8, ptr %79, i64 12
  %334 = add i16 %.pre1353, %321
  store i16 %334, ptr %333, align 1, !tbaa !17
  %335 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %336 = and i8 %335, 1
  %.not1047 = icmp eq i8 %336, 0
  %.phi.trans.insert1355 = getelementptr inbounds i8, ptr %22, i64 14
  %.pre1356 = load i16, ptr %.phi.trans.insert1355, align 1, !tbaa !17
  br i1 %.not1047, label %._crit_edge1354, label %337, !prof !22

._crit_edge1354:                                  ; preds = %._crit_edge1351
  %.pre1387 = sub i64 %312, %313
  br label %346

337:                                              ; preds = %._crit_edge1351
  %338 = zext i16 %.pre1356 to i64
  %339 = sub i64 %312, %313
  %340 = add i64 %339, %338
  %341 = icmp ugt i64 %340, 65535
  br i1 %341, label %342, label %346, !prof !22

342:                                              ; preds = %337
  %343 = load ptr, ptr %12, align 8, !tbaa !5
  %344 = getelementptr inbounds i8, ptr %343, i64 80
  %345 = load ptr, ptr %344, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %345, ptr noundef nonnull @.str.59, ptr noundef nonnull @__func__.page_split, i32 noundef 1089) #11
  unreachable

346:                                              ; preds = %._crit_edge1354, %337
  %.pre-phi1388 = phi i64 [ %.pre1387, %._crit_edge1354 ], [ %339, %337 ]
  %347 = trunc i64 %.pre-phi1388 to i16
  %348 = getelementptr inbounds i8, ptr %22, i64 14
  %349 = add i16 %.pre1356, %347
  store i16 %349, ptr %348, align 1, !tbaa !17
  %350 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %351 = and i8 %350, 1
  %.not1048 = icmp ne i8 %351, 0
  %.phi.trans.insert1358 = getelementptr inbounds i8, ptr %79, i64 14
  %.pre1359 = load i16, ptr %.phi.trans.insert1358, align 1, !tbaa !17
  %352 = zext i16 %.pre1359 to i64
  %.not1049 = icmp ugt i64 %.pre-phi1388, %352
  %or.cond1406 = select i1 %.not1048, i1 %.not1049, i1 false
  br i1 %or.cond1406, label %353, label %._crit_edge1357, !prof !45

353:                                              ; preds = %346
  %354 = load ptr, ptr %12, align 8, !tbaa !5
  %355 = getelementptr inbounds i8, ptr %354, i64 80
  %356 = load ptr, ptr %355, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %356, ptr noundef nonnull @.str.60, ptr noundef nonnull @__func__.page_split, i32 noundef 1091) #11
  unreachable

._crit_edge1357:                                  ; preds = %346
  %357 = getelementptr inbounds i8, ptr %79, i64 14
  %358 = sub i16 %.pre1359, %347
  store i16 %358, ptr %357, align 1, !tbaa !17
  %359 = getelementptr inbounds i8, ptr %11, i64 8
  store i64 %309, ptr %359, align 8, !tbaa !27
  %.not1050 = icmp eq i64 %.3922, %35
  br i1 %.not1050, label %360, label %362

360:                                              ; preds = %._crit_edge1357
  %361 = load ptr, ptr %1, align 8, !tbaa !46
  br label %362

362:                                              ; preds = %._crit_edge1357, %360
  %363 = phi ptr [ %361, %360 ], [ %310, %._crit_edge1357 ]
  store ptr %363, ptr %11, align 8, !tbaa !46
  %364 = icmp slt i64 %304, 0
  br i1 %364, label %365, label %424

365:                                              ; preds = %362
  %366 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %367 = and i8 %366, 1
  %.not1057 = icmp ne i8 %367, 0
  %368 = icmp ult i32 %308, 2
  %or.cond1138 = and i1 %368, %.not1057
  br i1 %or.cond1138, label %369, label %373, !prof !45

369:                                              ; preds = %365
  %370 = load ptr, ptr %12, align 8, !tbaa !5
  %371 = getelementptr inbounds i8, ptr %370, i64 80
  %372 = load ptr, ptr %371, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %372, ptr noundef nonnull @.str.61, ptr noundef nonnull @__func__.page_split, i32 noundef 1096) #11
  unreachable

373:                                              ; preds = %365
  %374 = load i8, ptr %18, align 1, !tbaa !17
  %375 = sext i8 %374 to i64
  %376 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %375
  %377 = load i16, ptr %376, align 2, !tbaa !23
  %378 = zext i16 %377 to i64
  %379 = call ptr @page_dupfix_ptr(ptr noundef nonnull %22, i64 noundef %378, i64 noundef %309) #12
  %380 = getelementptr inbounds i8, ptr %79, i64 20
  call void @llvm.memcpy.p0.p0.i64(ptr nonnull align 1 %380, ptr align 1 %310, i64 %312, i1 false)
  store ptr %380, ptr %11, align 8, !tbaa !46
  %381 = ptrtoint ptr %379 to i64
  %382 = add nsw i64 %381, %309
  %383 = inttoptr i64 %382 to ptr
  %384 = load i8, ptr %18, align 1, !tbaa !17
  %385 = sext i8 %384 to i64
  %386 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %385
  %387 = load i16, ptr %386, align 2, !tbaa !23
  %388 = zext i16 %387 to i64
  %389 = sub nsw i64 %.3922, %388
  %390 = mul i64 %389, %309
  call void @llvm.memmove.p0.p0.i64(ptr align 1 %383, ptr align 1 %379, i64 %390, i1 false)
  %391 = load ptr, ptr %1, align 8, !tbaa !46
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %379, ptr align 1 %391, i64 %309, i1 false)
  %392 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %393 = and i8 %392, 1
  %.not1058 = icmp ne i8 %393, 0
  %.pre1362 = load i16, ptr %322, align 1, !tbaa !17
  %394 = icmp ugt i16 %.pre1362, -3
  %or.cond1407 = select i1 %.not1058, i1 %394, i1 false
  br i1 %or.cond1407, label %395, label %399, !prof !45

395:                                              ; preds = %373
  %396 = load ptr, ptr %12, align 8, !tbaa !5
  %397 = getelementptr inbounds i8, ptr %396, i64 80
  %398 = load ptr, ptr %397, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %398, ptr noundef nonnull @.str.62, ptr noundef nonnull @__func__.page_split, i32 noundef 1102) #11
  unreachable

399:                                              ; preds = %373
  %400 = add i16 %.pre1362, 2
  store i16 %400, ptr %322, align 1, !tbaa !17
  %401 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %402 = and i8 %401, 1
  %.not1059 = icmp ne i8 %402, 0
  %.pre1363 = load i16, ptr %348, align 1, !tbaa !17
  %403 = zext i16 %.pre1363 to i64
  %404 = add nsw i64 %309, -2
  %.not1060 = icmp ugt i64 %404, %403
  %or.cond1409 = select i1 %.not1059, i1 %.not1060, i1 false
  br i1 %or.cond1409, label %405, label %409, !prof !45

405:                                              ; preds = %399
  %406 = load ptr, ptr %12, align 8, !tbaa !5
  %407 = getelementptr inbounds i8, ptr %406, i64 80
  %408 = load ptr, ptr %407, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %408, ptr noundef nonnull @.str.63, ptr noundef nonnull @__func__.page_split, i32 noundef 1104) #11
  unreachable

409:                                              ; preds = %399
  %410 = trunc i32 %308 to i16
  %reass.sub1321 = sub i16 %.pre1363, %410
  %411 = add i16 %reass.sub1321, 2
  store i16 %411, ptr %348, align 1, !tbaa !17
  %412 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %413 = and i8 %412, 1
  %.not1061 = icmp eq i8 %413, 0
  br i1 %.not1061, label %479, label %414, !prof !22

414:                                              ; preds = %409
  %415 = call i64 @page_numkeys(ptr noundef nonnull %22) #12
  %416 = and i64 %415, %309
  %417 = zext i16 %reass.sub1321 to i64
  %418 = xor i64 %416, %417
  %419 = and i64 %418, 1
  %.not1062 = icmp eq i64 %419, 0
  br i1 %.not1062, label %479, label %420, !prof !24

420:                                              ; preds = %414
  %421 = load ptr, ptr %12, align 8, !tbaa !5
  %422 = getelementptr inbounds i8, ptr %421, i64 80
  %423 = load ptr, ptr %422, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %423, ptr noundef nonnull @.str.64, ptr noundef nonnull @__func__.page_split, i32 noundef 1106) #11
  unreachable

424:                                              ; preds = %362
  %425 = getelementptr inbounds i8, ptr %79, i64 20
  %426 = mul nuw nsw i64 %304, %309
  call void @llvm.memcpy.p0.p0.i64(ptr nonnull align 1 %425, ptr align 1 %310, i64 %426, i1 false)
  %427 = call ptr @page_dupfix_ptr(ptr noundef nonnull %79, i64 noundef %304, i64 noundef %309) #12
  %428 = load ptr, ptr %1, align 8, !tbaa !46
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %427, ptr align 1 %428, i64 %309, i1 false)
  %429 = ptrtoint ptr %427 to i64
  %430 = add nsw i64 %429, %309
  %431 = inttoptr i64 %430 to ptr
  %432 = ptrtoint ptr %310 to i64
  %433 = add nsw i64 %426, %432
  %434 = inttoptr i64 %433 to ptr
  %435 = sub i64 %312, %426
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %431, ptr align 1 %434, i64 %435, i1 false)
  %436 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %437 = and i8 %436, 1
  %.not1051 = icmp ne i8 %437, 0
  %.pre1360 = load i16, ptr %333, align 1, !tbaa !17
  %438 = icmp ugt i16 %.pre1360, -3
  %or.cond1410 = select i1 %.not1051, i1 %438, i1 false
  br i1 %or.cond1410, label %439, label %443, !prof !45

439:                                              ; preds = %424
  %440 = load ptr, ptr %12, align 8, !tbaa !5
  %441 = getelementptr inbounds i8, ptr %440, i64 80
  %442 = load ptr, ptr %441, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %442, ptr noundef nonnull @.str.65, ptr noundef nonnull @__func__.page_split, i32 noundef 1112) #11
  unreachable

443:                                              ; preds = %424
  %444 = add i16 %.pre1360, 2
  store i16 %444, ptr %333, align 1, !tbaa !17
  %445 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %446 = and i8 %445, 1
  %.not1052 = icmp ne i8 %446, 0
  %.pre1361 = load i16, ptr %357, align 1, !tbaa !17
  %447 = zext i16 %.pre1361 to i64
  %448 = add nsw i64 %309, -2
  %.not1053 = icmp ugt i64 %448, %447
  %or.cond1412 = select i1 %.not1052, i1 %.not1053, i1 false
  br i1 %or.cond1412, label %449, label %453, !prof !45

449:                                              ; preds = %443
  %450 = load ptr, ptr %12, align 8, !tbaa !5
  %451 = getelementptr inbounds i8, ptr %450, i64 80
  %452 = load ptr, ptr %451, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %452, ptr noundef nonnull @.str.66, ptr noundef nonnull @__func__.page_split, i32 noundef 1114) #11
  unreachable

453:                                              ; preds = %443
  %454 = trunc i32 %308 to i16
  %reass.sub = sub i16 %.pre1361, %454
  %455 = add i16 %reass.sub, 2
  store i16 %455, ptr %357, align 1, !tbaa !17
  %456 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %457 = and i8 %456, 1
  %.not1054 = icmp ne i8 %457, 0
  %458 = icmp ugt i64 %304, 65535
  %or.cond1139 = select i1 %.not1054, i1 %458, i1 false
  br i1 %or.cond1139, label %459, label %463, !prof !45

459:                                              ; preds = %453
  %460 = load ptr, ptr %12, align 8, !tbaa !5
  %461 = getelementptr inbounds i8, ptr %460, i64 80
  %462 = load ptr, ptr %461, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %462, ptr noundef nonnull @.str.67, ptr noundef nonnull @__func__.page_split, i32 noundef 1116) #11
  unreachable

463:                                              ; preds = %453
  %464 = trunc i64 %304 to i16
  %465 = load i8, ptr %18, align 1, !tbaa !17
  %466 = sext i8 %465 to i64
  %467 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %466
  store i16 %464, ptr %467, align 2, !tbaa !23
  %.not1055 = icmp eq i8 %457, 0
  br i1 %.not1055, label %479, label %468, !prof !22

468:                                              ; preds = %463
  %469 = call i64 @page_numkeys(ptr noundef nonnull %79) #12
  %470 = and i64 %469, %309
  %471 = load i16, ptr %357, align 1, !tbaa !17
  %472 = zext i16 %471 to i64
  %473 = xor i64 %470, %472
  %474 = and i64 %473, 1
  %.not1056 = icmp eq i64 %474, 0
  br i1 %.not1056, label %479, label %475, !prof !24

475:                                              ; preds = %468
  %476 = load ptr, ptr %12, align 8, !tbaa !5
  %477 = getelementptr inbounds i8, ptr %476, i64 80
  %478 = load ptr, ptr %477, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %478, ptr noundef nonnull @.str.68, ptr noundef nonnull @__func__.page_split, i32 noundef 1118) #11
  unreachable

479:                                              ; preds = %463, %468, %409, %414
  %480 = phi i8 [ %456, %463 ], [ %456, %468 ], [ %412, %409 ], [ %412, %414 ]
  %481 = and i8 %480, 2
  %.not1063 = icmp eq i8 %481, 0
  br i1 %.not1063, label %thread-pre-split, label %482, !prof !24

482:                                              ; preds = %479
  %483 = call i32 @cursor_validate_updating(ptr noundef nonnull %0) #10
  %.not1064 = icmp eq i32 %483, 0
  br i1 %.not1064, label %484, label %.thread1253, !prof !24

484:                                              ; preds = %482
  %485 = call i32 @cursor_validate_updating(ptr noundef %154) #10
  %.not1065 = icmp eq i32 %485, 0
  br i1 %.not1065, label %thread-pre-split, label %.thread1253, !prof !24

486:                                              ; preds = %296
  %487 = load ptr, ptr %12, align 8, !tbaa !5
  %488 = call ptr @page_shadow_alloc(ptr noundef %487, i64 noundef 1) #10
  %489 = ptrtoint ptr %488 to i64
  %490 = icmp eq ptr %488, null
  br i1 %490, label %.thread1253, label %491, !prof !22

491:                                              ; preds = %486
  %492 = call i64 @page_space(ptr noundef %15) #12
  %493 = call zeroext i1 @is_leaf(ptr noundef %22) #12
  br i1 %493, label %494, label %496

494:                                              ; preds = %491
  %495 = call i64 @leaf_size(ptr noundef %15, ptr noundef %1, ptr noundef %2) #12
  br label %498

496:                                              ; preds = %491
  %497 = call i64 @branch_size(ptr noundef %15, ptr noundef %1) #12
  br label %498

498:                                              ; preds = %496, %494
  %499 = phi i64 [ %495, %494 ], [ %497, %496 ]
  %.not1320 = icmp eq i16 %34, 0
  br i1 %.not1320, label %._crit_edge, label %.lr.ph1284

.lr.ph1284:                                       ; preds = %498
  %500 = getelementptr inbounds i8, ptr %22, i64 20
  %501 = getelementptr inbounds i8, ptr %488, i64 20
  %min.iters.check = icmp ult i16 %34, 16
  %502 = sub i64 %489, %23
  %diff.check = icmp ult i64 %502, 32
  %or.cond1549 = select i1 %min.iters.check, i1 true, i1 %diff.check
  br i1 %or.cond1549, label %scalar.ph.preheader, label %vector.ph

vector.ph:                                        ; preds = %.lr.ph1284
  %n.vec = and i64 %35, 65520
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %503 = getelementptr inbounds [0 x i16], ptr %500, i64 0, i64 %index
  %504 = getelementptr inbounds i8, ptr %503, i64 16
  %wide.load = load <8 x i16>, ptr %503, align 1, !tbaa !23
  %wide.load1426 = load <8 x i16>, ptr %504, align 1, !tbaa !23
  %505 = getelementptr inbounds [0 x i16], ptr %501, i64 0, i64 %index
  %506 = getelementptr inbounds i8, ptr %505, i64 16
  store <8 x i16> %wide.load, ptr %505, align 1, !tbaa !23
  store <8 x i16> %wide.load1426, ptr %506, align 1, !tbaa !23
  %index.next = add nuw i64 %index, 16
  %507 = icmp eq i64 %index.next, %n.vec
  br i1 %507, label %middle.block, label %vector.body, !llvm.loop !47

middle.block:                                     ; preds = %vector.body
  %cmp.n = icmp eq i64 %n.vec, %35
  br i1 %cmp.n, label %._crit_edge, label %scalar.ph.preheader

scalar.ph.preheader:                              ; preds = %middle.block, %.lr.ph1284
  %.09271283.ph = phi i64 [ 0, %.lr.ph1284 ], [ %n.vec, %middle.block ]
  %xtraiter = and i64 %35, 3
  %lcmp.mod.not = icmp eq i64 %xtraiter, 0
  br i1 %lcmp.mod.not, label %scalar.ph.prol.loopexit, label %scalar.ph.prol

scalar.ph.prol:                                   ; preds = %scalar.ph.preheader, %scalar.ph.prol
  %.09271283.prol = phi i64 [ %511, %scalar.ph.prol ], [ %.09271283.ph, %scalar.ph.preheader ]
  %prol.iter = phi i64 [ %prol.iter.next, %scalar.ph.prol ], [ 0, %scalar.ph.preheader ]
  %508 = getelementptr inbounds [0 x i16], ptr %500, i64 0, i64 %.09271283.prol
  %509 = load i16, ptr %508, align 1, !tbaa !23
  %510 = getelementptr inbounds [0 x i16], ptr %501, i64 0, i64 %.09271283.prol
  store i16 %509, ptr %510, align 1, !tbaa !23
  %511 = add nuw nsw i64 %.09271283.prol, 1
  %prol.iter.next = add i64 %prol.iter, 1
  %prol.iter.cmp.not = icmp eq i64 %prol.iter.next, %xtraiter
  br i1 %prol.iter.cmp.not, label %scalar.ph.prol.loopexit, label %scalar.ph.prol, !llvm.loop !50

scalar.ph.prol.loopexit:                          ; preds = %scalar.ph.prol, %scalar.ph.preheader
  %.09271283.unr = phi i64 [ %.09271283.ph, %scalar.ph.preheader ], [ %511, %scalar.ph.prol ]
  %512 = sub nsw i64 %.09271283.ph, %35
  %513 = icmp ugt i64 %512, -4
  br i1 %513, label %._crit_edge, label %scalar.ph

scalar.ph:                                        ; preds = %scalar.ph.prol.loopexit, %scalar.ph
  %.09271283 = phi i64 [ %529, %scalar.ph ], [ %.09271283.unr, %scalar.ph.prol.loopexit ]
  %514 = getelementptr inbounds [0 x i16], ptr %500, i64 0, i64 %.09271283
  %515 = load i16, ptr %514, align 1, !tbaa !23
  %516 = getelementptr inbounds [0 x i16], ptr %501, i64 0, i64 %.09271283
  store i16 %515, ptr %516, align 1, !tbaa !23
  %517 = add nuw nsw i64 %.09271283, 1
  %518 = getelementptr inbounds [0 x i16], ptr %500, i64 0, i64 %517
  %519 = load i16, ptr %518, align 1, !tbaa !23
  %520 = getelementptr inbounds [0 x i16], ptr %501, i64 0, i64 %517
  store i16 %519, ptr %520, align 1, !tbaa !23
  %521 = add nuw nsw i64 %.09271283, 2
  %522 = getelementptr inbounds [0 x i16], ptr %500, i64 0, i64 %521
  %523 = load i16, ptr %522, align 1, !tbaa !23
  %524 = getelementptr inbounds [0 x i16], ptr %501, i64 0, i64 %521
  store i16 %523, ptr %524, align 1, !tbaa !23
  %525 = add nuw nsw i64 %.09271283, 3
  %526 = getelementptr inbounds [0 x i16], ptr %500, i64 0, i64 %525
  %527 = load i16, ptr %526, align 1, !tbaa !23
  %528 = getelementptr inbounds [0 x i16], ptr %501, i64 0, i64 %525
  store i16 %527, ptr %528, align 1, !tbaa !23
  %529 = add nuw nsw i64 %.09271283, 4
  %exitcond1335.not.3 = icmp eq i64 %529, %35
  br i1 %exitcond1335.not.3, label %._crit_edge, label %scalar.ph, !llvm.loop !52

._crit_edge:                                      ; preds = %scalar.ph.prol.loopexit, %scalar.ph, %middle.block, %498
  %530 = getelementptr inbounds i8, ptr %488, i64 20
  %531 = getelementptr inbounds [0 x i16], ptr %530, i64 0, i64 %35
  store i16 -1, ptr %531, align 1, !tbaa !23
  %.not10261285.not = icmp ugt i64 %36, %35
  br i1 %.not10261285.not, label %.lr.ph1288, label %._crit_edge1289

.lr.ph1288:                                       ; preds = %._crit_edge
  %532 = add nuw nsw i64 %35, 1
  %533 = getelementptr inbounds i8, ptr %22, i64 20
  %534 = add nuw nsw i64 %35, 2
  %umax = call i64 @llvm.umax.i64(i64 %534, i64 %170)
  %535 = xor i64 %35, -1
  %536 = add i64 %umax, %535
  %min.iters.check1431 = icmp ult i64 %536, 16
  br i1 %min.iters.check1431, label %scalar.ph1430.preheader, label %vector.memcheck1427

vector.memcheck1427:                              ; preds = %.lr.ph1288
  %537 = add i64 %489, 2
  %538 = sub i64 %537, %23
  %diff.check1428 = icmp ult i64 %538, 32
  br i1 %diff.check1428, label %scalar.ph1430.preheader, label %vector.ph1432

vector.ph1432:                                    ; preds = %vector.memcheck1427
  %n.vec1434 = and i64 %536, -16
  %ind.end = add i64 %532, %n.vec1434
  %ind.end1436 = add i64 %n.vec1434, %35
  br label %vector.body1438

vector.body1438:                                  ; preds = %vector.body1438, %vector.ph1432
  %index1439 = phi i64 [ 0, %vector.ph1432 ], [ %index.next1443, %vector.body1438 ]
  %offset.idx = add i64 %532, %index1439
  %offset.idx1440 = add i64 %index1439, %35
  %539 = getelementptr inbounds [0 x i16], ptr %533, i64 0, i64 %offset.idx1440
  %540 = getelementptr inbounds i8, ptr %539, i64 16
  %wide.load1441 = load <8 x i16>, ptr %539, align 1, !tbaa !23
  %wide.load1442 = load <8 x i16>, ptr %540, align 1, !tbaa !23
  %541 = getelementptr inbounds [0 x i16], ptr %530, i64 0, i64 %offset.idx
  %542 = getelementptr inbounds i8, ptr %541, i64 16
  store <8 x i16> %wide.load1441, ptr %541, align 1, !tbaa !23
  store <8 x i16> %wide.load1442, ptr %542, align 1, !tbaa !23
  %index.next1443 = add nuw i64 %index1439, 16
  %543 = icmp eq i64 %index.next1443, %n.vec1434
  br i1 %543, label %middle.block1429, label %vector.body1438, !llvm.loop !53

middle.block1429:                                 ; preds = %vector.body1438
  %cmp.n1444 = icmp eq i64 %536, %n.vec1434
  br i1 %cmp.n1444, label %._crit_edge1289, label %scalar.ph1430.preheader

scalar.ph1430.preheader:                          ; preds = %middle.block1429, %vector.memcheck1427, %.lr.ph1288
  %.ph = phi i64 [ %532, %vector.memcheck1427 ], [ %532, %.lr.ph1288 ], [ %ind.end, %middle.block1429 ]
  %.19281286.ph = phi i64 [ %35, %vector.memcheck1427 ], [ %35, %.lr.ph1288 ], [ %ind.end1436, %middle.block1429 ]
  br label %scalar.ph1430

scalar.ph1430:                                    ; preds = %scalar.ph1430.preheader, %scalar.ph1430
  %544 = phi i64 [ %548, %scalar.ph1430 ], [ %.ph, %scalar.ph1430.preheader ]
  %.19281286 = phi i64 [ %544, %scalar.ph1430 ], [ %.19281286.ph, %scalar.ph1430.preheader ]
  %545 = getelementptr inbounds [0 x i16], ptr %533, i64 0, i64 %.19281286
  %546 = load i16, ptr %545, align 1, !tbaa !23
  %547 = getelementptr inbounds [0 x i16], ptr %530, i64 0, i64 %544
  store i16 %546, ptr %547, align 1, !tbaa !23
  %548 = add i64 %544, 1
  %.not1026 = icmp ugt i64 %548, %36
  br i1 %.not1026, label %._crit_edge1289, label %scalar.ph1430, !llvm.loop !54

._crit_edge1289:                                  ; preds = %scalar.ph1430, %middle.block1429, %._crit_edge
  %549 = getelementptr inbounds i8, ptr %22, i64 16
  %550 = load i32, ptr %549, align 1, !tbaa !26
  %551 = getelementptr inbounds i8, ptr %488, i64 16
  store i32 %550, ptr %551, align 1, !tbaa !26
  %552 = load i16, ptr %41, align 1, !tbaa !23
  %553 = getelementptr inbounds i8, ptr %488, i64 10
  store i16 %552, ptr %553, align 1, !tbaa !23
  store i64 -1, ptr %488, align 1, !tbaa !33
  %554 = getelementptr inbounds i8, ptr %488, i64 12
  store i16 0, ptr %554, align 1, !tbaa !17
  %555 = trunc i64 %492 to i16
  %556 = getelementptr inbounds i8, ptr %488, i64 14
  store i16 %555, ptr %556, align 1, !tbaa !17
  %557 = icmp eq i64 %.3922, %35
  %558 = icmp ugt i64 %36, 4
  %or.cond5 = select i1 %557, i1 %558, i1 false
  br i1 %or.cond5, label %559, label %564

559:                                              ; preds = %._crit_edge1289
  %560 = load i16, ptr %41, align 1, !tbaa !23
  %561 = and i16 %560, 1
  %562 = zext nneg i16 %561 to i64
  %563 = add nuw nsw i64 %35, %562
  br label %564

564:                                              ; preds = %._crit_edge1289, %559
  %.4923 = phi i64 [ %563, %559 ], [ %.3922, %._crit_edge1289 ]
  %565 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %566 = and i8 %565, 1
  %.not1027 = icmp eq i8 %566, 0
  br i1 %.not1027, label %572, label %567, !prof !22

567:                                              ; preds = %564
  %.not1028 = icmp uge i64 %.4923, %44
  %568 = sub i64 %170, %44
  %569 = icmp ule i64 %.4923, %568
  %570 = select i1 %.not1028, i1 %569, i1 false
  br i1 %570, label %572, label %571, !prof !24

571:                                              ; preds = %567
  call void @mdbx_assert_fail(ptr noundef %15, ptr noundef nonnull @.str.69, ptr noundef nonnull @__func__.page_split, i32 noundef 1174) #11
  unreachable

572:                                              ; preds = %567, %564
  %.not1029 = icmp ugt i64 %.4923, %35
  %573 = sub i64 %36, %.4923
  %574 = select i1 %.not1029, i64 %573, i64 %.4923
  %575 = mul i64 %574, 11
  %.not1030 = icmp ult i64 %499, %575
  br i1 %.not1030, label %636, label %576

576:                                              ; preds = %572
  %577 = select i1 %.not1029, i64 0, i64 %36
  %578 = select i1 %.not1029, i64 1, i64 -1
  %579 = call i64 @page_used(ptr noundef %15, ptr noundef nonnull %22) #12
  %580 = add i64 %579, %499
  %581 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 26), align 2, !tbaa !25
  %582 = icmp ugt i8 %581, 5
  br i1 %582, label %583, label %584, !prof !22

583:                                              ; preds = %576
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef nonnull @__func__.page_split, i32 noundef 1187, ptr noundef nonnull @.str.70, i64 noundef %577, i64 noundef %578, i64 noundef %.4923, i64 noundef %35, i64 noundef %499) #10
  %.pre1346.pre = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  br label %584

584:                                              ; preds = %583, %576
  %.pre1346 = phi i8 [ %.pre1346.pre, %583 ], [ %565, %576 ]
  %585 = ptrtoint ptr %22 to i64
  %586 = add i64 %585, 20
  %587 = zext i1 %.not1029 to i64
  %588 = sub i64 %170, %44
  br label %589

589:                                              ; preds = %.thread1195, %584
  %590 = phi i8 [ %.pre1346, %584 ], [ %624, %.thread1195 ]
  %.0946 = phi i64 [ %580, %584 ], [ %619, %.thread1195 ]
  %.0940 = phi i64 [ %.4923, %584 ], [ %.4944, %.thread1195 ]
  %.0934 = phi i64 [ 2147483647, %584 ], [ %.4938, %.thread1195 ]
  %.0931 = phi i64 [ 0, %584 ], [ %618, %.thread1195 ]
  %.2929 = phi i64 [ %577, %584 ], [ %631, %.thread1195 ]
  %591 = and i8 %590, 1
  %.not1031 = icmp ne i8 %591, 0
  %.not1032 = icmp ugt i64 %.2929, %36
  %or.cond1140 = select i1 %.not1031, i1 %.not1032, i1 false
  br i1 %or.cond1140, label %592, label %596, !prof !45

592:                                              ; preds = %589
  %593 = load ptr, ptr %12, align 8, !tbaa !5
  %594 = getelementptr inbounds i8, ptr %593, i64 80
  %595 = load ptr, ptr %594, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %595, ptr noundef nonnull @.str.71, ptr noundef nonnull @__func__.page_split, i32 noundef 1189) #11
  unreachable

596:                                              ; preds = %589
  %.not1033 = icmp eq i64 %.2929, %35
  br i1 %.not1033, label %617, label %597

597:                                              ; preds = %596
  %598 = getelementptr inbounds [0 x i16], ptr %530, i64 0, i64 %.2929
  %599 = load i16, ptr %598, align 1, !tbaa !23
  %600 = zext i16 %599 to i64
  %601 = add i64 %586, %600
  %602 = inttoptr i64 %601 to ptr
  %603 = call i64 @node_ks(ptr noundef %602) #12
  %604 = add i64 %603, 10
  %605 = call zeroext i1 @is_leaf(ptr noundef %22) #12
  br i1 %605, label %606, label %614

606:                                              ; preds = %597
  %607 = call zeroext i8 @node_flags(ptr noundef %602) #12
  %608 = and i8 %607, 1
  %.not1034 = icmp eq i8 %608, 0
  br i1 %.not1034, label %609, label %611

609:                                              ; preds = %606
  %610 = call i64 @node_ds(ptr noundef %602) #12
  br label %611

611:                                              ; preds = %606, %609
  %612 = phi i64 [ %610, %609 ], [ 4, %606 ]
  %613 = add i64 %612, %604
  br label %614

614:                                              ; preds = %611, %597
  %.0932 = phi i64 [ %613, %611 ], [ %604, %597 ]
  %615 = add i64 %.0932, 1
  %616 = and i64 %615, -2
  br label %617

617:                                              ; preds = %614, %596
  %.1933 = phi i64 [ %616, %614 ], [ %499, %596 ]
  %618 = add i64 %.1933, %.0931
  %619 = sub i64 %.0946, %.1933
  %620 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 26), align 2, !tbaa !25
  %621 = icmp ugt i8 %620, 5
  br i1 %621, label %622, label %623, !prof !22

622:                                              ; preds = %617
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef nonnull @__func__.page_split, i32 noundef 1201, ptr noundef nonnull @.str.72, i64 noundef %.2929, i64 noundef %.1933, i64 noundef %618, i64 noundef %619, i64 noundef %492) #10
  %.pre1345 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  br label %623

623:                                              ; preds = %622, %617
  %624 = phi i8 [ %.pre1345, %622 ], [ %590, %617 ]
  %.not1035 = icmp ugt i64 %618, %492
  %.not1036 = icmp ugt i64 %619, %492
  %or.cond1141 = select i1 %.not1035, i1 true, i1 %.not1036
  br i1 %or.cond1141, label %.thread1195, label %625

625:                                              ; preds = %623
  %626 = add nuw i64 %.2929, %587
  %.not1037 = icmp ult i64 %626, %44
  %.not1038 = icmp ugt i64 %626, %588
  %or.cond1260 = select i1 %.not1037, i1 true, i1 %.not1038
  br i1 %or.cond1260, label %.thread1195, label %627

627:                                              ; preds = %625
  %628 = sub i64 %.4923, %626
  %629 = call i64 @branchless_abs(i64 noundef %628) #13
  %.fr = freeze i64 %629
  %.not1039 = icmp ult i64 %.fr, %.0934
  br i1 %.not1039, label %630, label %.thread1206

630:                                              ; preds = %627
  %.not1040.not = icmp eq i64 %.fr, 0
  br i1 %.not1040.not, label %.thread1206, label %.thread1195

.thread1195:                                      ; preds = %630, %625, %623
  %.4944 = phi i64 [ %.0940, %623 ], [ %.0940, %625 ], [ %626, %630 ]
  %.4938 = phi i64 [ %.0934, %623 ], [ %.0934, %625 ], [ %.fr, %630 ]
  %631 = add i64 %.2929, %578
  %632 = icmp ult i64 %631, %36
  br i1 %632, label %589, label %.thread1206, !llvm.loop !55

.thread1206:                                      ; preds = %630, %627, %.thread1195
  %.59451213 = phi i64 [ %.4944, %.thread1195 ], [ %.0940, %627 ], [ %626, %630 ]
  %633 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 26), align 2, !tbaa !25
  %634 = icmp ugt i8 %633, 5
  br i1 %634, label %635, label %636, !prof !22

635:                                              ; preds = %.thread1206
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef nonnull @__func__.page_split, i32 noundef 1219, ptr noundef nonnull @.str.73, i64 noundef %.59451213) #10
  %.pre1347 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  br label %636

636:                                              ; preds = %.thread1206, %635, %572
  %637 = phi i8 [ %565, %572 ], [ %.pre1347, %635 ], [ %624, %.thread1206 ]
  %.5924 = phi i64 [ %.4923, %572 ], [ %.59451213, %635 ], [ %.59451213, %.thread1206 ]
  %638 = and i8 %637, 1
  %.not1041 = icmp eq i8 %638, 0
  br i1 %.not1041, label %644, label %639, !prof !22

639:                                              ; preds = %636
  %.not1042 = icmp uge i64 %.5924, %44
  %640 = sub i64 %170, %44
  %641 = icmp ule i64 %.5924, %640
  %642 = select i1 %.not1042, i1 %641, i1 false
  br i1 %642, label %644, label %643, !prof !24

643:                                              ; preds = %639
  call void @mdbx_assert_fail(ptr noundef %15, ptr noundef nonnull @.str.69, ptr noundef nonnull @__func__.page_split, i32 noundef 1221) #11
  unreachable

644:                                              ; preds = %639, %636
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %11, ptr noundef nonnull align 8 dereferenceable(16) %1, i64 16, i1 false), !tbaa.struct !43
  %.not1043 = icmp eq i64 %.5924, %35
  br i1 %.not1043, label %thread-pre-split, label %645

645:                                              ; preds = %644
  %646 = ptrtoint ptr %22 to i64
  %647 = getelementptr inbounds [0 x i16], ptr %530, i64 0, i64 %.5924
  %648 = load i16, ptr %647, align 1, !tbaa !23
  %649 = zext i16 %648 to i64
  %650 = add i64 %646, 20
  %651 = add i64 %650, %649
  %652 = inttoptr i64 %651 to ptr
  %653 = call i64 @node_ks(ptr noundef %652) #12
  %654 = getelementptr inbounds i8, ptr %11, i64 8
  store i64 %653, ptr %654, align 8, !tbaa !27
  %655 = call ptr @node_key(ptr noundef %652) #12
  store ptr %655, ptr %11, align 8, !tbaa !46
  br label %thread-pre-split

thread-pre-split:                                 ; preds = %484, %479, %294, %275, %645, %644
  %.6925.ph = phi i64 [ %35, %644 ], [ %.5924, %645 ], [ 0, %294 ], [ %36, %275 ], [ %.3922, %479 ], [ %.3922, %484 ]
  %.0899.ph = phi ptr [ %488, %644 ], [ %488, %645 ], [ null, %294 ], [ null, %275 ], [ null, %479 ], [ null, %484 ]
  %.pr1214 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 26), align 2, !tbaa !25
  br label %656

656:                                              ; preds = %thread-pre-split, %291
  %657 = phi i8 [ %.pr1214, %thread-pre-split ], [ %292, %291 ]
  %.6925 = phi i64 [ %.6925.ph, %thread-pre-split ], [ 0, %291 ]
  %.0899 = phi ptr [ %.0899.ph, %thread-pre-split ], [ null, %291 ]
  %.08991464 = ptrtoint ptr %.0899 to i64
  %658 = icmp ugt i8 %657, 4
  br i1 %658, label %659, label %661, !prof !22

659:                                              ; preds = %656
  %660 = call ptr @mdbx_dump_val(ptr noundef nonnull %11, ptr noundef nonnull %9, i64 noundef 255) #10
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 5, ptr noundef nonnull @__func__.page_split, i32 noundef 1231, ptr noundef nonnull @.str.74, i64 noundef %.6925, ptr noundef %660) #10
  br label %661

661:                                              ; preds = %659, %656
  %662 = getelementptr inbounds [32 x ptr], ptr %156, i64 0, i64 %.1915
  %663 = load ptr, ptr %662, align 8, !tbaa !18
  %664 = call i64 @page_room(ptr noundef %663) #12
  %665 = call i64 @branch_size(ptr noundef %15, ptr noundef nonnull %11) #12
  %666 = icmp ult i64 %664, %665
  br i1 %666, label %667, label %791

667:                                              ; preds = %661
  %668 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 26), align 2, !tbaa !25
  %669 = icmp ugt i8 %668, 5
  br i1 %669, label %670, label %672, !prof !22

670:                                              ; preds = %667
  %671 = call ptr @mdbx_dump_val(ptr noundef nonnull %11, ptr noundef nonnull %9, i64 noundef 255) #10
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef nonnull @__func__.page_split, i32 noundef 1236, ptr noundef nonnull @.str.75, ptr noundef %671) #10
  br label %672

672:                                              ; preds = %667, %670
  %673 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %674 = and i8 %673, 1
  %.not1080.not = icmp eq i8 %674, 0
  br i1 %.not1080.not, label %.thread1215, label %675, !prof !22

675:                                              ; preds = %672
  %676 = load ptr, ptr %662, align 8, !tbaa !18
  %677 = call i64 @page_numkeys(ptr noundef %676) #12
  %678 = icmp ult i64 %677, 3
  br i1 %678, label %679, label %683, !prof !22

679:                                              ; preds = %675
  %680 = load ptr, ptr %12, align 8, !tbaa !5
  %681 = getelementptr inbounds i8, ptr %680, i64 80
  %682 = load ptr, ptr %681, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %682, ptr noundef nonnull @.str.76, ptr noundef nonnull @__func__.page_split, i32 noundef 1237) #11
  unreachable

683:                                              ; preds = %675
  br i1 %259, label %684, label %.thread1215, !prof !56

684:                                              ; preds = %683
  %685 = load ptr, ptr %12, align 8, !tbaa !5
  %686 = getelementptr inbounds i8, ptr %685, i64 80
  %687 = load ptr, ptr %686, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %687, ptr noundef nonnull @.str.77, ptr noundef nonnull @__func__.page_split, i32 noundef 1238) #11
  unreachable

.thread1215:                                      ; preds = %672, %683
  %688 = load i8, ptr %18, align 1, !tbaa !17
  %689 = sext i8 %688 to i32
  %690 = getelementptr inbounds i8, ptr %0, i64 24
  %691 = load ptr, ptr %690, align 8, !tbaa !29
  %692 = getelementptr inbounds i8, ptr %691, i64 2
  %693 = load i16, ptr %692, align 2, !tbaa !30
  %694 = zext i16 %693 to i32
  %695 = load i8, ptr %157, align 1, !tbaa !17
  %696 = add i8 %695, -1
  store i8 %696, ptr %157, align 1, !tbaa !17
  %697 = getelementptr inbounds i8, ptr %154, i64 16
  %698 = load ptr, ptr %697, align 8, !tbaa !5
  %699 = getelementptr inbounds i8, ptr %698, i64 120
  %700 = load ptr, ptr %699, align 8, !tbaa !57
  %701 = call i64 @cursor_dbi(ptr noundef nonnull %154) #12
  %702 = getelementptr inbounds ptr, ptr %700, i64 %701
  %703 = load ptr, ptr %702, align 8, !tbaa !18
  %704 = getelementptr inbounds i8, ptr %10, i64 368
  store ptr %703, ptr %704, align 8, !tbaa !58
  %705 = call i64 @cursor_dbi(ptr noundef nonnull %154) #12
  %706 = getelementptr inbounds ptr, ptr %700, i64 %705
  store ptr %10, ptr %706, align 8, !tbaa !18
  %707 = getelementptr inbounds i8, ptr %79, i64 16
  %708 = load i32, ptr %707, align 1, !tbaa !26
  %709 = call i32 @page_split(ptr noundef nonnull %154, ptr noundef nonnull %11, ptr noundef null, i32 noundef %708, i32 noundef 0)
  %710 = load ptr, ptr %704, align 8, !tbaa !58
  %711 = load ptr, ptr %697, align 8, !tbaa !5
  %712 = getelementptr inbounds i8, ptr %711, i64 120
  %713 = load ptr, ptr %712, align 8, !tbaa !57
  %714 = call i64 @cursor_dbi(ptr noundef nonnull %154) #12
  %715 = getelementptr inbounds ptr, ptr %713, i64 %714
  store ptr %710, ptr %715, align 8, !tbaa !18
  %.not1082 = icmp eq i32 %709, 0
  br i1 %.not1082, label %716, label %.thread1219, !prof !24

716:                                              ; preds = %.thread1215
  %717 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %718 = and i8 %717, 1
  %.not1083 = icmp eq i8 %718, 0
  br i1 %.not1083, label %732, label %719, !prof !22

719:                                              ; preds = %716
  %720 = load i8, ptr %18, align 1, !tbaa !17
  %721 = sext i8 %720 to i32
  %722 = sub nsw i32 %721, %689
  %723 = load ptr, ptr %690, align 8, !tbaa !29
  %724 = getelementptr inbounds i8, ptr %723, i64 2
  %725 = load i16, ptr %724, align 2, !tbaa !30
  %726 = zext i16 %725 to i32
  %727 = sub nsw i32 %726, %694
  %.not1084 = icmp eq i32 %722, %727
  br i1 %.not1084, label %732, label %728, !prof !24

728:                                              ; preds = %719
  %729 = load ptr, ptr %12, align 8, !tbaa !5
  %730 = getelementptr inbounds i8, ptr %729, i64 80
  %731 = load ptr, ptr %730, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %731, ptr noundef nonnull @.str.78, ptr noundef nonnull @__func__.page_split, i32 noundef 1249) #11
  unreachable

732:                                              ; preds = %719, %716
  %733 = and i8 %717, 2
  %.not1085 = icmp eq i8 %733, 0
  br i1 %.not1085, label %736, label %734, !prof !24

734:                                              ; preds = %732
  %735 = call i32 @cursor_validate_updating(ptr noundef nonnull %0) #10
  %.not1086 = icmp eq i32 %735, 0
  br i1 %.not1086, label %._crit_edge1365, label %.thread1219, !prof !24

._crit_edge1365:                                  ; preds = %734
  %.pre1366 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %.pre1382 = and i8 %.pre1366, 1
  br label %736

736:                                              ; preds = %._crit_edge1365, %732
  %.pre-phi = phi i8 [ %.pre1382, %._crit_edge1365 ], [ %718, %732 ]
  %737 = load i8, ptr %18, align 1, !tbaa !17
  %738 = sext i8 %737 to i32
  %739 = sub nsw i32 %738, %689
  %740 = sext i32 %739 to i64
  %741 = add nsw i64 %.1915, %740
  %.not1087 = icmp eq i8 %.pre-phi, 0
  br i1 %.not1087, label %752, label %742, !prof !22

742:                                              ; preds = %736
  %743 = load i8, ptr %157, align 1, !tbaa !17
  %744 = sext i8 %743 to i64
  %.not1088 = icmp sle i64 %741, %744
  %745 = sext i8 %737 to i64
  %746 = icmp sle i64 %741, %745
  %747 = select i1 %.not1088, i1 %746, i1 false
  br i1 %747, label %752, label %748, !prof !24

748:                                              ; preds = %742
  %749 = load ptr, ptr %697, align 8, !tbaa !5
  %750 = getelementptr inbounds i8, ptr %749, i64 80
  %751 = load ptr, ptr %750, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %751, ptr noundef nonnull @.str.79, ptr noundef nonnull @__func__.page_split, i32 noundef 1258) #11
  unreachable

752:                                              ; preds = %742, %736
  %753 = getelementptr inbounds [32 x ptr], ptr %156, i64 0, i64 %741
  %754 = load ptr, ptr %753, align 8, !tbaa !18
  %755 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %741
  %756 = load ptr, ptr %755, align 8, !tbaa !18
  %.not1089 = icmp eq ptr %754, %756
  br i1 %.not1089, label %941, label %757

757:                                              ; preds = %752
  %758 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %741
  %759 = load i16, ptr %758, align 2, !tbaa !23
  %760 = zext i16 %759 to i64
  %761 = call i64 @page_numkeys(ptr noundef %756) #12
  %.not1090 = icmp ugt i64 %761, %760
  br i1 %.not1090, label %941, label %.preheader1275

.preheader1275:                                   ; preds = %757
  %762 = icmp sgt i64 %741, 0
  br i1 %762, label %.lr.ph1291.preheader, label %._crit_edge1292

.lr.ph1291.preheader:                             ; preds = %.preheader1275
  %min.iters.check1450 = icmp ult i64 %741, 6
  %763 = sub i64 %6, %155
  %diff.check1446 = icmp ult i64 %763, 32
  %or.cond1550 = or i1 %min.iters.check1450, %diff.check1446
  br i1 %or.cond1550, label %.lr.ph1291.preheader1566, label %vector.ph1451

.lr.ph1291.preheader1566:                         ; preds = %middle.block1448, %.lr.ph1291.preheader
  %.09131290.ph = phi i64 [ 0, %.lr.ph1291.preheader ], [ %n.vec1453, %middle.block1448 ]
  br label %.lr.ph1291

vector.ph1451:                                    ; preds = %.lr.ph1291.preheader
  %n.vec1453 = and i64 %741, 9223372036854775804
  br label %vector.body1455

vector.body1455:                                  ; preds = %vector.body1455, %vector.ph1451
  %index1456 = phi i64 [ 0, %vector.ph1451 ], [ %index.next1461, %vector.body1455 ]
  %764 = getelementptr inbounds [32 x ptr], ptr %156, i64 0, i64 %index1456
  %765 = getelementptr inbounds i8, ptr %764, i64 16
  %wide.load1457 = load <2 x ptr>, ptr %764, align 8, !tbaa !18
  %wide.load1458 = load <2 x ptr>, ptr %765, align 8, !tbaa !18
  %766 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %index1456
  %767 = getelementptr inbounds i8, ptr %766, i64 16
  store <2 x ptr> %wide.load1457, ptr %766, align 8, !tbaa !18
  store <2 x ptr> %wide.load1458, ptr %767, align 8, !tbaa !18
  %768 = getelementptr inbounds [32 x i16], ptr %161, i64 0, i64 %index1456
  %769 = getelementptr inbounds i8, ptr %768, i64 4
  %wide.load1459 = load <2 x i16>, ptr %768, align 2, !tbaa !23
  %wide.load1460 = load <2 x i16>, ptr %769, align 2, !tbaa !23
  %770 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %index1456
  %771 = getelementptr inbounds i8, ptr %770, i64 4
  store <2 x i16> %wide.load1459, ptr %770, align 2, !tbaa !23
  store <2 x i16> %wide.load1460, ptr %771, align 2, !tbaa !23
  %index.next1461 = add nuw i64 %index1456, 4
  %772 = icmp eq i64 %index.next1461, %n.vec1453
  br i1 %772, label %middle.block1448, label %vector.body1455, !llvm.loop !61

middle.block1448:                                 ; preds = %vector.body1455
  %cmp.n1462 = icmp eq i64 %741, %n.vec1453
  br i1 %cmp.n1462, label %._crit_edge1292.loopexit, label %.lr.ph1291.preheader1566

._crit_edge1292.loopexit:                         ; preds = %.lr.ph1291, %middle.block1448
  %.pre1367 = load ptr, ptr %753, align 8, !tbaa !18
  br label %._crit_edge1292

._crit_edge1292:                                  ; preds = %._crit_edge1292.loopexit, %.preheader1275
  %773 = phi ptr [ %.pre1367, %._crit_edge1292.loopexit ], [ %754, %.preheader1275 ]
  store ptr %773, ptr %755, align 8, !tbaa !18
  %774 = getelementptr inbounds [32 x i16], ptr %161, i64 0, i64 %741
  %775 = load i16, ptr %774, align 2, !tbaa !23
  %.not1091 = icmp eq i16 %775, 0
  br i1 %.not1091, label %786, label %784

.lr.ph1291:                                       ; preds = %.lr.ph1291.preheader1566, %.lr.ph1291
  %.09131290 = phi i64 [ %782, %.lr.ph1291 ], [ %.09131290.ph, %.lr.ph1291.preheader1566 ]
  %776 = getelementptr inbounds [32 x ptr], ptr %156, i64 0, i64 %.09131290
  %777 = load ptr, ptr %776, align 8, !tbaa !18
  %778 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %.09131290
  store ptr %777, ptr %778, align 8, !tbaa !18
  %779 = getelementptr inbounds [32 x i16], ptr %161, i64 0, i64 %.09131290
  %780 = load i16, ptr %779, align 2, !tbaa !23
  %781 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %.09131290
  store i16 %780, ptr %781, align 2, !tbaa !23
  %782 = add nuw nsw i64 %.09131290, 1
  %783 = icmp slt i64 %782, %741
  br i1 %783, label %.lr.ph1291, label %._crit_edge1292.loopexit, !llvm.loop !62

784:                                              ; preds = %._crit_edge1292
  %785 = add i16 %775, -1
  store i16 %785, ptr %758, align 2, !tbaa !23
  br label %941

786:                                              ; preds = %._crit_edge1292
  store i16 0, ptr %758, align 2, !tbaa !23
  %787 = call i32 @cursor_sibling_left(ptr noundef nonnull %0) #10
  switch i32 %787, label %.thread1219 [
    i32 0, label %941
    i32 -30798, label %788
  ], !prof !63

788:                                              ; preds = %786
  %789 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 26), align 2, !tbaa !25
  %.not1093 = icmp eq i8 %789, 0
  br i1 %.not1093, label %.thread1219, label %790, !prof !24

790:                                              ; preds = %788
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 1, ptr noundef nonnull @__func__.page_split, i32 noundef 1276, ptr noundef nonnull @.str.80, i32 noundef -30798) #10
  br label %.thread1219

791:                                              ; preds = %661
  br i1 %259, label %792, label %925, !prof !22

792:                                              ; preds = %791
  %793 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %.1915
  %794 = load ptr, ptr %793, align 8, !tbaa !18
  %795 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 26), align 2, !tbaa !25
  %796 = icmp ugt i8 %795, 5
  br i1 %796, label %797, label %806, !prof !22

797:                                              ; preds = %792
  %798 = getelementptr inbounds i8, ptr %794, i64 16
  %799 = load i32, ptr %798, align 1, !tbaa !26
  %800 = load i16, ptr %165, align 2, !tbaa !23
  %801 = zext i16 %800 to i32
  %802 = getelementptr inbounds i8, ptr %79, i64 16
  %803 = load i32, ptr %802, align 1, !tbaa !26
  %.not1069 = icmp eq i16 %800, 0
  %804 = select i1 %.not1069, ptr null, ptr %1
  %805 = call ptr @mdbx_dump_val(ptr noundef %804, ptr noundef nonnull %9, i64 noundef 255) #10
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef nonnull @__func__.page_split, i32 noundef 1287, ptr noundef nonnull @.str.81, i32 noundef %799, i32 noundef %801, i32 noundef %803, ptr noundef %805) #10
  br label %806

806:                                              ; preds = %792, %797
  %807 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %808 = and i8 %807, 1
  %.not1070 = icmp eq i8 %808, 0
  br i1 %.not1070, label %814, label %809, !prof !22

809:                                              ; preds = %806
  %810 = load i8, ptr %18, align 1, !tbaa !17
  %811 = sext i8 %810 to i64
  %812 = add nsw i64 %.1915, 1
  %.not1071 = icmp eq i64 %812, %811
  br i1 %.not1071, label %814, label %813, !prof !24

813:                                              ; preds = %809
  call void @mdbx_assert_fail(ptr noundef null, ptr noundef nonnull @.str.82, ptr noundef nonnull @__func__.page_split, i32 noundef 1288) #11
  unreachable

814:                                              ; preds = %809, %806
  %815 = trunc i64 %.1915 to i8
  store i8 %815, ptr %18, align 1, !tbaa !17
  %816 = load i16, ptr %165, align 2, !tbaa !23
  %817 = zext i16 %816 to i64
  %.not1072 = icmp eq i16 %816, 0
  %818 = select i1 %.not1072, ptr null, ptr %1
  %819 = getelementptr inbounds i8, ptr %79, i64 16
  %820 = load i32, ptr %819, align 1, !tbaa !26
  %821 = call i32 @node_add_branch(ptr noundef nonnull %0, i64 noundef %817, ptr noundef %818, i32 noundef %820) #10
  %822 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %823 = and i8 %822, 1
  %.not1073 = icmp eq i8 %823, 0
  br i1 %.not1073, label %840, label %824, !prof !22

824:                                              ; preds = %814
  %825 = add nsw i64 %.1915, 1
  %826 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %825
  %827 = load ptr, ptr %826, align 8, !tbaa !18
  %828 = icmp eq ptr %22, %827
  br i1 %828, label %829, label %.critedge, !prof !24

829:                                              ; preds = %824
  %830 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %825
  %831 = load i16, ptr %830, align 2, !tbaa !23
  %832 = icmp eq i16 %34, %831
  br i1 %832, label %833, label %.critedge, !prof !24

833:                                              ; preds = %829
  %834 = load i8, ptr %18, align 1, !tbaa !17
  %835 = sext i8 %834 to i64
  %836 = icmp eq i64 %.1915, %835
  br i1 %836, label %840, label %.critedge, !prof !24

.critedge:                                        ; preds = %829, %824, %833
  %837 = load ptr, ptr %12, align 8, !tbaa !5
  %838 = getelementptr inbounds i8, ptr %837, i64 80
  %839 = load ptr, ptr %838, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %839, ptr noundef nonnull @.str.83, ptr noundef nonnull @__func__.page_split, i32 noundef 1291) #11
  unreachable

840:                                              ; preds = %833, %814
  %841 = icmp eq i32 %821, 0
  br i1 %841, label %842, label %899, !prof !24

842:                                              ; preds = %840
  %843 = load i16, ptr %165, align 2, !tbaa !23
  %844 = icmp eq i16 %843, 0
  br i1 %844, label %845, label %899

845:                                              ; preds = %842
  %846 = load ptr, ptr %793, align 8, !tbaa !18
  %847 = call ptr @page_node(ptr noundef %846, i64 noundef 1) #12
  %848 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 26), align 2, !tbaa !25
  %849 = icmp ugt i8 %848, 5
  br i1 %849, label %850, label %852, !prof !22

850:                                              ; preds = %845
  %851 = call ptr @mdbx_dump_val(ptr noundef nonnull %11, ptr noundef nonnull %9, i64 noundef 255) #10
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef nonnull @__func__.page_split, i32 noundef 1295, ptr noundef nonnull @.str.84, ptr noundef %851) #10
  %.pre1364 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %.pre1385 = and i8 %.pre1364, 1
  br label %852

852:                                              ; preds = %845, %850
  %.pre-phi1386 = phi i8 [ %823, %845 ], [ %.pre1385, %850 ]
  %.not1074 = icmp eq i8 %.pre-phi1386, 0
  br i1 %.not1074, label %.thread1223, label %853, !prof !22

853:                                              ; preds = %852
  %854 = call i64 @node_ks(ptr noundef %847) #12
  %855 = icmp eq i64 %854, 0
  br i1 %855, label %856, label %.critedge1148, !prof !24

856:                                              ; preds = %853
  %857 = call i32 @node_pgno(ptr noundef %847) #12
  %858 = getelementptr inbounds i8, ptr %22, i64 16
  %859 = load i32, ptr %858, align 1, !tbaa !26
  %860 = icmp eq i32 %857, %859
  br i1 %860, label %864, label %.critedge1148, !prof !24

.critedge1148:                                    ; preds = %853, %856
  %861 = load ptr, ptr %12, align 8, !tbaa !5
  %862 = getelementptr inbounds i8, ptr %861, i64 80
  %863 = load ptr, ptr %862, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %863, ptr noundef nonnull @.str.85, ptr noundef nonnull @__func__.page_split, i32 noundef 1296) #11
  unreachable

864:                                              ; preds = %856
  %865 = load i8, ptr %18, align 1, !tbaa !17
  %866 = sext i8 %865 to i64
  %867 = icmp eq i64 %.1915, %866
  br i1 %867, label %868, label %.critedge1150, !prof !24

868:                                              ; preds = %864
  %869 = load i16, ptr %165, align 2, !tbaa !23
  %870 = icmp eq i16 %869, 0
  br i1 %870, label %.thread1223, label %.critedge1150, !prof !24

.critedge1150:                                    ; preds = %864, %868
  %871 = load ptr, ptr %12, align 8, !tbaa !5
  %872 = getelementptr inbounds i8, ptr %871, i64 80
  %873 = load ptr, ptr %872, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %873, ptr noundef nonnull @.str.86, ptr noundef nonnull @__func__.page_split, i32 noundef 1297) #11
  unreachable

.thread1223:                                      ; preds = %852, %868
  store i16 1, ptr %165, align 2, !tbaa !23
  %874 = call i32 @tree_propagate_key(ptr noundef nonnull %0, ptr noundef nonnull %11)
  %875 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %876 = and i8 %875, 1
  %.not1076 = icmp eq i8 %876, 0
  br i1 %.not1076, label %.thread1224, label %877, !prof !22

877:                                              ; preds = %.thread1223
  %878 = load i8, ptr %18, align 1, !tbaa !17
  %879 = sext i8 %878 to i64
  %880 = icmp eq i64 %.1915, %879
  br i1 %880, label %881, label %.critedge1152, !prof !24

881:                                              ; preds = %877
  %882 = load i16, ptr %165, align 2, !tbaa !23
  %883 = icmp eq i16 %882, 1
  br i1 %883, label %887, label %.critedge1152, !prof !24

.critedge1152:                                    ; preds = %877, %881
  %884 = load ptr, ptr %12, align 8, !tbaa !5
  %885 = getelementptr inbounds i8, ptr %884, i64 80
  %886 = load ptr, ptr %885, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %886, ptr noundef nonnull @.str.87, ptr noundef nonnull @__func__.page_split, i32 noundef 1300) #11
  unreachable

887:                                              ; preds = %881
  %888 = add nsw i64 %.1915, 1
  %889 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %888
  %890 = load ptr, ptr %889, align 8, !tbaa !18
  %891 = icmp eq ptr %22, %890
  br i1 %891, label %892, label %.critedge1154, !prof !24

892:                                              ; preds = %887
  %893 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %888
  %894 = load i16, ptr %893, align 2, !tbaa !23
  %895 = icmp eq i16 %34, %894
  br i1 %895, label %.thread1224, label %.critedge1154, !prof !24

.critedge1154:                                    ; preds = %887, %892
  %896 = load ptr, ptr %12, align 8, !tbaa !5
  %897 = getelementptr inbounds i8, ptr %896, i64 80
  %898 = load ptr, ptr %897, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %898, ptr noundef nonnull @.str.88, ptr noundef nonnull @__func__.page_split, i32 noundef 1301) #11
  unreachable

.thread1224:                                      ; preds = %.thread1223, %892
  store i16 0, ptr %165, align 2, !tbaa !23
  br label %904

899:                                              ; preds = %840, %842
  %900 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 26), align 2, !tbaa !25
  %901 = icmp ugt i8 %900, 5
  br i1 %901, label %902, label %904, !prof !22

902:                                              ; preds = %899
  %903 = call ptr @mdbx_dump_val(ptr noundef nonnull %11, ptr noundef nonnull %9, i64 noundef 255) #10
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef nonnull @__func__.page_split, i32 noundef 1304, ptr noundef nonnull @.str.89, ptr noundef %903) #10
  br label %904

904:                                              ; preds = %899, %902, %.thread1224
  %.10 = phi i32 [ %874, %.thread1224 ], [ %821, %902 ], [ %821, %899 ]
  %905 = load i8, ptr %18, align 1, !tbaa !17
  %906 = add i8 %905, 1
  store i8 %906, ptr %18, align 1, !tbaa !17
  %.not1078 = icmp eq i32 %.10, 0
  br i1 %.not1078, label %907, label %.thread1219, !prof !24

907:                                              ; preds = %904
  %908 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %909 = and i8 %908, 1
  %.not1079 = icmp eq i8 %909, 0
  br i1 %.not1079, label %.thread1228, label %910, !prof !22

910:                                              ; preds = %907
  %911 = load ptr, ptr %793, align 8, !tbaa !18
  %912 = load i16, ptr %165, align 2, !tbaa !23
  %913 = zext i16 %912 to i64
  %914 = add nuw nsw i64 %913, 1
  %915 = call ptr @page_node(ptr noundef %911, i64 noundef %914) #12
  %916 = call i32 @node_pgno(ptr noundef %915) #12
  %917 = getelementptr inbounds i8, ptr %22, i64 16
  %918 = load i32, ptr %917, align 1, !tbaa !26
  %919 = icmp eq i32 %916, %918
  %920 = icmp eq ptr %911, %794
  %spec.select1155 = select i1 %919, i1 %920, i1 false, !prof !24
  br i1 %spec.select1155, label %.thread1228, label %921, !prof !24

921:                                              ; preds = %910
  %922 = load ptr, ptr %12, align 8, !tbaa !5
  %923 = getelementptr inbounds i8, ptr %922, i64 80
  %924 = load ptr, ptr %923, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %924, ptr noundef nonnull @.str.90, ptr noundef nonnull @__func__.page_split, i32 noundef 1312) #11
  unreachable

925:                                              ; preds = %791
  %926 = load i8, ptr %157, align 1, !tbaa !17
  %927 = add i8 %926, -1
  store i8 %927, ptr %157, align 1, !tbaa !17
  %928 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 26), align 2, !tbaa !25
  %929 = icmp ugt i8 %928, 5
  br i1 %929, label %930, label %933, !prof !22

930:                                              ; preds = %925
  %931 = load i16, ptr %168, align 2, !tbaa !23
  %932 = zext i16 %931 to i32
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef nonnull @__func__.page_split, i32 noundef 1315, ptr noundef nonnull @.str.91, i32 noundef %932) #10
  br label %933

933:                                              ; preds = %930, %925
  %934 = load i16, ptr %168, align 2, !tbaa !23
  %935 = zext i16 %934 to i64
  %936 = getelementptr inbounds i8, ptr %79, i64 16
  %937 = load i32, ptr %936, align 1, !tbaa !26
  %938 = call i32 @node_add_branch(ptr noundef nonnull %154, i64 noundef %935, ptr noundef nonnull %11, i32 noundef %937) #10
  %939 = load i8, ptr %157, align 1, !tbaa !17
  %940 = add i8 %939, 1
  store i8 %940, ptr %157, align 1, !tbaa !17
  %.not1068 = icmp eq i32 %938, 0
  br i1 %.not1068, label %941, label %.thread1219, !prof !24

941:                                              ; preds = %786, %784, %757, %752, %933
  %.3917 = phi i64 [ %.1915, %933 ], [ %741, %752 ], [ %741, %757 ], [ %741, %784 ], [ %741, %786 ]
  %942 = or i1 %259, %258
  br i1 %942, label %..thread1228_crit_edge, label %1084, !prof !64

..thread1228_crit_edge:                           ; preds = %941
  %.pre1368 = load i8, ptr %18, align 1, !tbaa !17
  br label %.thread1228

.thread1228:                                      ; preds = %..thread1228_crit_edge, %910, %907
  %943 = phi i8 [ %.pre1368, %..thread1228_crit_edge ], [ %906, %907 ], [ %906, %910 ]
  %.39171232 = phi i64 [ %.3917, %..thread1228_crit_edge ], [ %.1915, %907 ], [ %.1915, %910 ]
  %944 = sext i8 %943 to i64
  %945 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %944
  store ptr %79, ptr %945, align 8, !tbaa !18
  %946 = load i8, ptr %18, align 1, !tbaa !17
  %947 = sext i8 %946 to i64
  %948 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %947
  store i16 0, ptr %948, align 2, !tbaa !23
  %949 = call zeroext i8 @page_type(ptr noundef %79) #12
  switch i8 %949, label %978 [
    i8 2, label %950
    i8 34, label %961
  ]

950:                                              ; preds = %.thread1228
  %951 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %952 = and i8 %951, 1
  %.not1114 = icmp ne i8 %952, 0
  %953 = add i32 %3, -1
  %954 = icmp ult i32 %953, -2
  %or.cond1157 = and i1 %954, %.not1114
  br i1 %or.cond1157, label %955, label %959, !prof !45

955:                                              ; preds = %950
  %956 = load ptr, ptr %12, align 8, !tbaa !5
  %957 = getelementptr inbounds i8, ptr %956, i64 80
  %958 = load ptr, ptr %957, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %958, ptr noundef nonnull @.str.92, ptr noundef nonnull @__func__.page_split, i32 noundef 1327) #11
  unreachable

959:                                              ; preds = %950
  %960 = call i32 @node_add_leaf(ptr noundef nonnull %0, i64 noundef 0, ptr noundef %1, ptr noundef %2, i32 noundef %4) #10
  br label %981

961:                                              ; preds = %.thread1228
  %962 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %963 = and i8 %962, 1
  %.not1111 = icmp eq i8 %963, 0
  %964 = and i32 %4, 7
  %.not1112 = icmp eq i32 %964, 0
  %or.cond1158 = or i1 %.not1112, %.not1111
  br i1 %or.cond1158, label %969, label %965, !prof !65

965:                                              ; preds = %961
  %966 = load ptr, ptr %12, align 8, !tbaa !5
  %967 = getelementptr inbounds i8, ptr %966, i64 80
  %968 = load ptr, ptr %967, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %968, ptr noundef nonnull @.str.93, ptr noundef nonnull @__func__.page_split, i32 noundef 1331) #11
  unreachable

969:                                              ; preds = %961
  %.not1113 = icmp ne i8 %963, 0
  %970 = add i32 %3, -1
  %971 = icmp ult i32 %970, -2
  %or.cond1160 = and i1 %971, %.not1113
  br i1 %or.cond1160, label %972, label %976, !prof !45

972:                                              ; preds = %969
  %973 = load ptr, ptr %12, align 8, !tbaa !5
  %974 = getelementptr inbounds i8, ptr %973, i64 80
  %975 = load ptr, ptr %974, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %975, ptr noundef nonnull @.str.92, ptr noundef nonnull @__func__.page_split, i32 noundef 1332) #11
  unreachable

976:                                              ; preds = %969
  %977 = call i32 @node_add_dupfix(ptr noundef nonnull %0, i64 noundef 0, ptr noundef %1) #10
  br label %981

978:                                              ; preds = %.thread1228
  %979 = zext i8 %949 to i32
  %980 = call i32 (ptr, ptr, ...) @bad_page(ptr noundef %79, ptr noundef nonnull @.str.94, i32 noundef %979) #10
  br label %981

981:                                              ; preds = %978, %976, %959
  %.12 = phi i32 [ %980, %978 ], [ %977, %976 ], [ %960, %959 ]
  %.not1115 = icmp eq i32 %.12, 0
  br i1 %.not1115, label %982, label %.thread1219, !prof !24

982:                                              ; preds = %981
  %983 = load i8, ptr %18, align 1, !tbaa !17
  %984 = sext i8 %983 to i64
  br i1 %258, label %.preheader, label %1041

.preheader:                                       ; preds = %982
  %985 = icmp sgt i8 %983, 0
  br i1 %985, label %.lr.ph1307.preheader, label %.thread1234

.lr.ph1307.preheader:                             ; preds = %.preheader
  %min.iters.check1519 = icmp ult i8 %983, 16
  %986 = sub i64 %6, %155
  %diff.check1516 = icmp ult i64 %986, 32
  %or.cond1551 = or i1 %min.iters.check1519, %diff.check1516
  br i1 %or.cond1551, label %.lr.ph1307.preheader1555, label %vector.ph1520

vector.ph1520:                                    ; preds = %.lr.ph1307.preheader
  %n.vec1522 = and i64 %984, 112
  %987 = getelementptr inbounds i8, ptr %154, i64 320
  %wide.load1526 = load <8 x i16>, ptr %161, align 2, !tbaa !23
  %wide.load1527 = load <8 x i16>, ptr %987, align 2, !tbaa !23
  %988 = getelementptr inbounds i8, ptr %0, i64 320
  store <8 x i16> %wide.load1526, ptr %32, align 2, !tbaa !23
  store <8 x i16> %wide.load1527, ptr %988, align 2, !tbaa !23
  %989 = icmp eq i64 %n.vec1522, 16
  br i1 %989, label %middle.block1517, label %vector.body1524.1, !llvm.loop !66

vector.body1524.1:                                ; preds = %vector.ph1520
  %990 = getelementptr inbounds i8, ptr %154, i64 336
  %991 = getelementptr inbounds i8, ptr %154, i64 352
  %wide.load1526.1 = load <8 x i16>, ptr %990, align 2, !tbaa !23
  %wide.load1527.1 = load <8 x i16>, ptr %991, align 2, !tbaa !23
  %992 = getelementptr inbounds i8, ptr %0, i64 336
  %993 = getelementptr inbounds i8, ptr %0, i64 352
  store <8 x i16> %wide.load1526.1, ptr %992, align 2, !tbaa !23
  store <8 x i16> %wide.load1527.1, ptr %993, align 2, !tbaa !23
  %994 = icmp eq i64 %n.vec1522, 32
  br i1 %994, label %middle.block1517, label %vector.body1524.2, !llvm.loop !66

vector.body1524.2:                                ; preds = %vector.body1524.1
  %995 = getelementptr inbounds i8, ptr %154, i64 368
  %996 = getelementptr inbounds i8, ptr %154, i64 384
  %wide.load1526.2 = load <8 x i16>, ptr %995, align 2, !tbaa !23
  %wide.load1527.2 = load <8 x i16>, ptr %996, align 2, !tbaa !23
  %997 = getelementptr inbounds i8, ptr %0, i64 368
  %998 = getelementptr inbounds i8, ptr %0, i64 384
  store <8 x i16> %wide.load1526.2, ptr %997, align 2, !tbaa !23
  store <8 x i16> %wide.load1527.2, ptr %998, align 2, !tbaa !23
  %999 = icmp eq i64 %n.vec1522, 48
  br i1 %999, label %middle.block1517, label %vector.body1524.3, !llvm.loop !66

vector.body1524.3:                                ; preds = %vector.body1524.2
  %1000 = getelementptr inbounds i8, ptr %154, i64 400
  %1001 = getelementptr inbounds i8, ptr %154, i64 416
  %wide.load1526.3 = load <8 x i16>, ptr %1000, align 2, !tbaa !23
  %wide.load1527.3 = load <8 x i16>, ptr %1001, align 2, !tbaa !23
  %1002 = getelementptr inbounds i8, ptr %0, i64 400
  %1003 = getelementptr inbounds i8, ptr %0, i64 416
  store <8 x i16> %wide.load1526.3, ptr %1002, align 2, !tbaa !23
  store <8 x i16> %wide.load1527.3, ptr %1003, align 2, !tbaa !23
  %1004 = icmp eq i64 %n.vec1522, 64
  br i1 %1004, label %middle.block1517, label %vector.body1524.4, !llvm.loop !66

vector.body1524.4:                                ; preds = %vector.body1524.3
  %1005 = getelementptr inbounds i8, ptr %154, i64 432
  %1006 = getelementptr inbounds i8, ptr %154, i64 448
  %wide.load1526.4 = load <8 x i16>, ptr %1005, align 2, !tbaa !23
  %wide.load1527.4 = load <8 x i16>, ptr %1006, align 2, !tbaa !23
  %1007 = getelementptr inbounds i8, ptr %0, i64 432
  %1008 = getelementptr inbounds i8, ptr %0, i64 448
  store <8 x i16> %wide.load1526.4, ptr %1007, align 2, !tbaa !23
  store <8 x i16> %wide.load1527.4, ptr %1008, align 2, !tbaa !23
  %1009 = icmp eq i64 %n.vec1522, 80
  br i1 %1009, label %middle.block1517, label %vector.body1524.5, !llvm.loop !66

vector.body1524.5:                                ; preds = %vector.body1524.4
  %1010 = getelementptr inbounds i8, ptr %154, i64 464
  %1011 = getelementptr inbounds i8, ptr %154, i64 480
  %wide.load1526.5 = load <8 x i16>, ptr %1010, align 2, !tbaa !23
  %wide.load1527.5 = load <8 x i16>, ptr %1011, align 2, !tbaa !23
  %1012 = getelementptr inbounds i8, ptr %0, i64 464
  %1013 = getelementptr inbounds i8, ptr %0, i64 480
  store <8 x i16> %wide.load1526.5, ptr %1012, align 2, !tbaa !23
  store <8 x i16> %wide.load1527.5, ptr %1013, align 2, !tbaa !23
  %1014 = icmp eq i64 %n.vec1522, 96
  br i1 %1014, label %middle.block1517, label %vector.body1524.6, !llvm.loop !66

vector.body1524.6:                                ; preds = %vector.body1524.5
  %1015 = getelementptr inbounds i8, ptr %154, i64 496
  %1016 = getelementptr inbounds i8, ptr %154, i64 512
  %wide.load1526.6 = load <8 x i16>, ptr %1015, align 2, !tbaa !23
  %wide.load1527.6 = load <8 x i16>, ptr %1016, align 2, !tbaa !23
  %1017 = getelementptr inbounds i8, ptr %0, i64 496
  %1018 = getelementptr inbounds i8, ptr %0, i64 512
  store <8 x i16> %wide.load1526.6, ptr %1017, align 2, !tbaa !23
  store <8 x i16> %wide.load1527.6, ptr %1018, align 2, !tbaa !23
  br label %middle.block1517

middle.block1517:                                 ; preds = %vector.body1524.6, %vector.body1524.5, %vector.body1524.4, %vector.body1524.3, %vector.body1524.2, %vector.body1524.1, %vector.ph1520
  %cmp.n1529 = icmp eq i64 %n.vec1522, %984
  br i1 %cmp.n1529, label %.thread1234, label %.lr.ph1307.preheader1555

.lr.ph1307.preheader1555:                         ; preds = %middle.block1517, %.lr.ph1307.preheader
  %.09021306.ph = phi i64 [ 0, %.lr.ph1307.preheader ], [ %n.vec1522, %middle.block1517 ]
  %xtraiter1580 = and i64 %984, 3
  %lcmp.mod1581.not = icmp eq i64 %xtraiter1580, 0
  br i1 %lcmp.mod1581.not, label %.lr.ph1307.prol.loopexit, label %.lr.ph1307.prol

.lr.ph1307.prol:                                  ; preds = %.lr.ph1307.preheader1555, %.lr.ph1307.prol
  %.09021306.prol = phi i64 [ %1022, %.lr.ph1307.prol ], [ %.09021306.ph, %.lr.ph1307.preheader1555 ]
  %prol.iter1582 = phi i64 [ %prol.iter1582.next, %.lr.ph1307.prol ], [ 0, %.lr.ph1307.preheader1555 ]
  %1019 = getelementptr inbounds [32 x i16], ptr %161, i64 0, i64 %.09021306.prol
  %1020 = load i16, ptr %1019, align 2, !tbaa !23
  %1021 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %.09021306.prol
  store i16 %1020, ptr %1021, align 2, !tbaa !23
  %1022 = add nuw nsw i64 %.09021306.prol, 1
  %prol.iter1582.next = add i64 %prol.iter1582, 1
  %prol.iter1582.cmp.not = icmp eq i64 %prol.iter1582.next, %xtraiter1580
  br i1 %prol.iter1582.cmp.not, label %.lr.ph1307.prol.loopexit, label %.lr.ph1307.prol, !llvm.loop !67

.lr.ph1307.prol.loopexit:                         ; preds = %.lr.ph1307.prol, %.lr.ph1307.preheader1555
  %.09021306.unr = phi i64 [ %.09021306.ph, %.lr.ph1307.preheader1555 ], [ %1022, %.lr.ph1307.prol ]
  %1023 = sub nsw i64 %.09021306.ph, %984
  %1024 = icmp ugt i64 %1023, -4
  br i1 %1024, label %.thread1234, label %.lr.ph1307

.lr.ph1307:                                       ; preds = %.lr.ph1307.prol.loopexit, %.lr.ph1307
  %.09021306 = phi i64 [ %1040, %.lr.ph1307 ], [ %.09021306.unr, %.lr.ph1307.prol.loopexit ]
  %1025 = getelementptr inbounds [32 x i16], ptr %161, i64 0, i64 %.09021306
  %1026 = load i16, ptr %1025, align 2, !tbaa !23
  %1027 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %.09021306
  store i16 %1026, ptr %1027, align 2, !tbaa !23
  %1028 = add nuw nsw i64 %.09021306, 1
  %1029 = getelementptr inbounds [32 x i16], ptr %161, i64 0, i64 %1028
  %1030 = load i16, ptr %1029, align 2, !tbaa !23
  %1031 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %1028
  store i16 %1030, ptr %1031, align 2, !tbaa !23
  %1032 = add nuw nsw i64 %.09021306, 2
  %1033 = getelementptr inbounds [32 x i16], ptr %161, i64 0, i64 %1032
  %1034 = load i16, ptr %1033, align 2, !tbaa !23
  %1035 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %1032
  store i16 %1034, ptr %1035, align 2, !tbaa !23
  %1036 = add nuw nsw i64 %.09021306, 3
  %1037 = getelementptr inbounds [32 x i16], ptr %161, i64 0, i64 %1036
  %1038 = load i16, ptr %1037, align 2, !tbaa !23
  %1039 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %1036
  store i16 %1038, ptr %1039, align 2, !tbaa !23
  %1040 = add nuw nsw i64 %.09021306, 4
  %exitcond1341.not.3 = icmp eq i64 %1040, %984
  br i1 %exitcond1341.not.3, label %.thread1234, label %.lr.ph1307, !llvm.loop !68

1041:                                             ; preds = %982
  %1042 = add nsw i64 %984, -1
  %1043 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %1042
  %1044 = load i16, ptr %1043, align 2, !tbaa !23
  %1045 = icmp ne i16 %1044, 0
  %.not11161303 = icmp slt i8 %983, 2
  %or.cond1317 = or i1 %1045, %.not11161303
  br i1 %or.cond1317, label %.thread1234, label %.lr.ph1305

.lr.ph1305:                                       ; preds = %1041, %1082
  %.09011304 = phi i64 [ %1083, %1082 ], [ 2, %1041 ]
  %1046 = sub nsw i64 %984, %.09011304
  %1047 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %1046
  %1048 = load i16, ptr %1047, align 2, !tbaa !23
  %.not1117 = icmp eq i16 %1048, 0
  br i1 %.not1117, label %1082, label %1049

1049:                                             ; preds = %.lr.ph1305
  %1050 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %1046
  %1051 = load ptr, ptr %1050, align 8, !tbaa !18
  %1052 = zext i16 %1048 to i64
  %1053 = call ptr @page_node(ptr noundef %1051, i64 noundef %1052) #12
  %1054 = call { ptr, i64 } @get_key(ptr noundef %1053) #12
  %1055 = extractvalue { ptr, i64 } %1054, 0
  %1056 = extractvalue { ptr, i64 } %1054, 1
  store ptr %1055, ptr %11, align 8, !tbaa !18
  %.sroa.4.0..sroa_idx = getelementptr inbounds i8, ptr %11, i64 8
  store i64 %1056, ptr %.sroa.4.0..sroa_idx, align 8, !tbaa !33
  %1057 = getelementptr inbounds i8, ptr %0, i64 32
  %1058 = load ptr, ptr %1057, align 8, !tbaa !34
  %1059 = load ptr, ptr %1058, align 8, !tbaa !35
  %1060 = call i32 %1059(ptr noundef %1, ptr noundef nonnull %11) #10
  %1061 = icmp slt i32 %1060, 0
  br i1 %1061, label %1062, label %.thread1234

1062:                                             ; preds = %1049
  %1063 = trunc i64 %.09011304 to i8
  %1064 = load i8, ptr %18, align 1, !tbaa !17
  %1065 = sub i8 %1064, %1063
  store i8 %1065, ptr %18, align 1, !tbaa !17
  %1066 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 26), align 2, !tbaa !25
  %1067 = icmp ugt i8 %1066, 4
  br i1 %1067, label %1068, label %1078, !prof !22

1068:                                             ; preds = %1062
  %1069 = sext i8 %1065 to i64
  %1070 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %1069
  %1071 = load i16, ptr %1070, align 2, !tbaa !23
  %1072 = zext i16 %1071 to i32
  %1073 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %1069
  %1074 = load ptr, ptr %1073, align 8, !tbaa !18
  %1075 = getelementptr inbounds i8, ptr %1074, i64 16
  %1076 = load i32, ptr %1075, align 1, !tbaa !26
  %1077 = call ptr @mdbx_dump_val(ptr noundef %1, ptr noundef nonnull %9, i64 noundef 255) #10
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 5, ptr noundef nonnull @__func__.page_split, i32 noundef 1351, ptr noundef nonnull @.str.95, i32 noundef %1072, i32 noundef %1076, ptr noundef %1077) #10
  br label %1078

1078:                                             ; preds = %1068, %1062
  %1079 = call i32 @tree_propagate_key(ptr noundef nonnull %0, ptr noundef %1)
  %1080 = load i8, ptr %18, align 1, !tbaa !17
  %1081 = add i8 %1080, %1063
  store i8 %1081, ptr %18, align 1, !tbaa !17
  %.not1118 = icmp eq i32 %1079, 0
  br i1 %.not1118, label %.thread1234, label %.thread1219, !prof !24

1082:                                             ; preds = %.lr.ph1305
  %1083 = add nuw nsw i64 %.09011304, 1
  %exitcond1340.not = icmp eq i64 %.09011304, %984
  br i1 %exitcond1340.not, label %.thread1234, label %.lr.ph1305, !llvm.loop !69

1084:                                             ; preds = %941
  %.not1094 = icmp eq ptr %.0899, null
  br i1 %.not1094, label %1276, label %1085

1085:                                             ; preds = %1084
  %1086 = load i8, ptr %18, align 1, !tbaa !17
  %1087 = sext i8 %1086 to i64
  %1088 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %1087
  store ptr %79, ptr %1088, align 8, !tbaa !18
  %1089 = getelementptr inbounds i8, ptr %79, i64 16
  %1090 = ptrtoint ptr %22 to i64
  %1091 = getelementptr i8, ptr %.0899, i64 20
  %1092 = add i64 %1090, 20
  %1093 = getelementptr inbounds i8, ptr %7, i64 8
  %1094 = getelementptr inbounds i8, ptr %8, i64 8
  %1095 = getelementptr inbounds i8, ptr %.0899, i64 16
  br label %1096

1096:                                             ; preds = %1168, %1085
  %.0895 = phi i64 [ 0, %1085 ], [ %.2897.ph, %1168 ]
  %.0892 = phi i64 [ %.6925, %1085 ], [ %.2894.ph, %1168 ]
  %1097 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 26), align 2, !tbaa !25
  %1098 = icmp ugt i8 %1097, 5
  br i1 %1098, label %1099, label %1101, !prof !22

1099:                                             ; preds = %1096
  %1100 = load i32, ptr %1089, align 1, !tbaa !26
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef nonnull @__func__.page_split, i32 noundef 1365, ptr noundef nonnull @.str.96, i64 noundef %.0892, i64 noundef %36, i64 noundef %.0895, i32 noundef %1100) #10
  br label %1101

1101:                                             ; preds = %1099, %1096
  %1102 = icmp eq i64 %.0892, %35
  br i1 %1102, label %1103, label %1109

1103:                                             ; preds = %1101
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %7, ptr noundef nonnull align 8 dereferenceable(16) %1, i64 16, i1 false), !tbaa.struct !43
  %1104 = call zeroext i1 @is_leaf(ptr noundef %22) #12
  %.1161 = select i1 %1104, i32 0, i32 %3
  %.1162 = select i1 %1104, ptr %2, ptr null
  %1105 = trunc i64 %.0895 to i16
  %1106 = load i8, ptr %18, align 1, !tbaa !17
  %1107 = sext i8 %1106 to i64
  %1108 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %1107
  store i16 %1105, ptr %1108, align 2, !tbaa !23
  br label %1126

1109:                                             ; preds = %1101
  %1110 = getelementptr inbounds [0 x i16], ptr %1091, i64 0, i64 %.0892
  %1111 = load i16, ptr %1110, align 1, !tbaa !23
  %1112 = zext i16 %1111 to i64
  %1113 = add i64 %1092, %1112
  %1114 = inttoptr i64 %1113 to ptr
  %1115 = call ptr @node_key(ptr noundef %1114) #12
  store ptr %1115, ptr %7, align 8, !tbaa !46
  %1116 = call i64 @node_ks(ptr noundef %1114) #12
  store i64 %1116, ptr %1093, align 8, !tbaa !27
  %1117 = call zeroext i1 @is_leaf(ptr noundef %22) #12
  br i1 %1117, label %1118, label %1121

1118:                                             ; preds = %1109
  %1119 = call ptr @node_data(ptr noundef %1114) #12
  store ptr %1119, ptr %8, align 8, !tbaa !46
  %1120 = call i64 @node_ds(ptr noundef %1114) #12
  store i64 %1120, ptr %1094, align 8, !tbaa !27
  br label %1123

1121:                                             ; preds = %1109
  %1122 = call i32 @node_pgno(ptr noundef %1114) #12
  br label %1123

1123:                                             ; preds = %1121, %1118
  %.1890 = phi i32 [ 0, %1118 ], [ %1122, %1121 ]
  %.1887 = phi ptr [ %8, %1118 ], [ null, %1121 ]
  %1124 = call zeroext i8 @node_flags(ptr noundef %1114) #12
  %1125 = zext i8 %1124 to i32
  br label %1126

1126:                                             ; preds = %1123, %1103
  %.2891 = phi i32 [ %.1161, %1103 ], [ %.1890, %1123 ]
  %.2888 = phi ptr [ %.1162, %1103 ], [ %.1887, %1123 ]
  %.0878 = phi i32 [ %4, %1103 ], [ %1125, %1123 ]
  %1127 = call zeroext i8 @page_type(ptr noundef %79) #12
  switch i8 %1127, label %1152 [
    i8 1, label %1128
    i8 2, label %1138
  ]

1128:                                             ; preds = %1126
  %1129 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %1130 = and i8 %1129, 1
  %.not1103 = icmp eq i8 %1130, 0
  %1131 = and i32 %.0878, 65535
  %.not1104 = icmp eq i32 %1131, 0
  %or.cond1163 = select i1 %.not1103, i1 true, i1 %.not1104
  br i1 %or.cond1163, label %1136, label %1132, !prof !65

1132:                                             ; preds = %1128
  %1133 = load ptr, ptr %12, align 8, !tbaa !5
  %1134 = getelementptr inbounds i8, ptr %1133, i64 80
  %1135 = load ptr, ptr %1134, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %1135, ptr noundef nonnull @.str.97, ptr noundef nonnull @__func__.page_split, i32 noundef 1392) #11
  unreachable

1136:                                             ; preds = %1128
  %.not1105 = icmp eq i64 %.0895, 0
  %. = select i1 %.not1105, ptr null, ptr %7
  %1137 = call i32 @node_add_branch(ptr noundef %0, i64 noundef %.0895, ptr noundef %., i32 noundef %.2891) #10
  br label %1155

1138:                                             ; preds = %1126
  %1139 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %1140 = and i8 %1139, 1
  %.not1099 = icmp eq i8 %1140, 0
  %.not1100 = icmp eq i32 %.2891, 0
  %or.cond1164 = select i1 %.not1099, i1 true, i1 %.not1100
  br i1 %or.cond1164, label %1145, label %1141, !prof !65

1141:                                             ; preds = %1138
  %1142 = load ptr, ptr %12, align 8, !tbaa !5
  %1143 = getelementptr inbounds i8, ptr %1142, i64 80
  %1144 = load ptr, ptr %1143, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %1144, ptr noundef nonnull @.str.98, ptr noundef nonnull @__func__.page_split, i32 noundef 1397) #11
  unreachable

1145:                                             ; preds = %1138
  %.not1101 = icmp ne i8 %1140, 0
  %.not1102 = icmp eq ptr %.2888, null
  %or.cond1165 = select i1 %.not1101, i1 %.not1102, i1 false
  br i1 %or.cond1165, label %1146, label %1150, !prof !45

1146:                                             ; preds = %1145
  %1147 = load ptr, ptr %12, align 8, !tbaa !5
  %1148 = getelementptr inbounds i8, ptr %1147, i64 80
  %1149 = load ptr, ptr %1148, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %1149, ptr noundef nonnull @.str.99, ptr noundef nonnull @__func__.page_split, i32 noundef 1398) #11
  unreachable

1150:                                             ; preds = %1145
  %1151 = call i32 @node_add_leaf(ptr noundef %0, i64 noundef %.0895, ptr noundef nonnull %7, ptr noundef %.2888, i32 noundef %.0878) #10
  br label %1155

1152:                                             ; preds = %1126
  %1153 = zext i8 %1127 to i32
  %1154 = call i32 (ptr, ptr, ...) @bad_page(ptr noundef %79, ptr noundef nonnull @.str.94, i32 noundef %1153) #10
  br label %1155

1155:                                             ; preds = %1152, %1150, %1136
  %.15 = phi i32 [ %1154, %1152 ], [ %1151, %1150 ], [ %1137, %1136 ]
  %.not1106 = icmp eq i32 %.15, 0
  br i1 %.not1106, label %1156, label %.thread1219, !prof !24

1156:                                             ; preds = %1155
  %1157 = add i64 %.0895, 1
  %1158 = add i64 %.0892, 1
  %1159 = icmp ugt i64 %1158, %36
  br i1 %1159, label %1160, label %1168

1160:                                             ; preds = %1156
  %1161 = load i8, ptr %18, align 1, !tbaa !17
  %1162 = sext i8 %1161 to i64
  %1163 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %1162
  store ptr %.0899, ptr %1163, align 8, !tbaa !18
  %1164 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 26), align 2, !tbaa !25
  %1165 = icmp ugt i8 %1164, 5
  br i1 %1165, label %1166, label %1168, !prof !22

1166:                                             ; preds = %1160
  %1167 = load i32, ptr %1095, align 1, !tbaa !26
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef nonnull @__func__.page_split, i32 noundef 1417, ptr noundef nonnull @.str.100, i32 noundef %1167) #10
  br label %1168

1168:                                             ; preds = %1156, %1166, %1160
  %.2897.ph = phi i64 [ %1157, %1156 ], [ 0, %1160 ], [ 0, %1166 ]
  %.2894.ph = phi i64 [ %1158, %1156 ], [ 0, %1160 ], [ 0, %1166 ]
  %.not1107 = icmp eq i64 %.2894.ph, %.6925
  br i1 %.not1107, label %1169, label %1096, !llvm.loop !70

1169:                                             ; preds = %1168
  %1170 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 26), align 2, !tbaa !25
  %1171 = icmp ugt i8 %1170, 5
  br i1 %1171, label %1172, label %1179, !prof !22

1172:                                             ; preds = %1169
  %1173 = load i8, ptr %18, align 1, !tbaa !17
  %1174 = sext i8 %1173 to i64
  %1175 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %1174
  %1176 = load ptr, ptr %1175, align 8, !tbaa !18
  %1177 = getelementptr inbounds i8, ptr %1176, i64 16
  %1178 = load i32, ptr %1177, align 1, !tbaa !26
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef nonnull @__func__.page_split, i32 noundef 1421, ptr noundef nonnull @.str.101, i64 noundef %.6925, i64 noundef %36, i64 noundef %.2897.ph, i32 noundef %1178) #10
  br label %1179

1179:                                             ; preds = %1172, %1169
  %1180 = call i64 @page_numkeys(ptr noundef nonnull %.0899) #12
  %.not1322 = icmp eq i64 %1180, 0
  br i1 %.not1322, label %._crit_edge1296, label %.lr.ph1295

.lr.ph1295:                                       ; preds = %1179
  %1181 = getelementptr inbounds i8, ptr %22, i64 20
  %min.iters.check1468 = icmp ult i64 %1180, 16
  %1182 = sub i64 %23, %.08991464
  %diff.check1465 = icmp ult i64 %1182, 32
  %or.cond1552 = select i1 %min.iters.check1468, i1 true, i1 %diff.check1465
  br i1 %or.cond1552, label %scalar.ph1467.preheader, label %vector.ph1469

scalar.ph1467.preheader:                          ; preds = %middle.block1466, %.lr.ph1295
  %.08821293.ph = phi i64 [ 0, %.lr.ph1295 ], [ %n.vec1471, %middle.block1466 ]
  %xtraiter1571 = and i64 %1180, 3
  %lcmp.mod1572.not = icmp eq i64 %xtraiter1571, 0
  br i1 %lcmp.mod1572.not, label %scalar.ph1467.prol.loopexit, label %scalar.ph1467.prol

scalar.ph1467.prol:                               ; preds = %scalar.ph1467.preheader, %scalar.ph1467.prol
  %.08821293.prol = phi i64 [ %1186, %scalar.ph1467.prol ], [ %.08821293.ph, %scalar.ph1467.preheader ]
  %prol.iter1573 = phi i64 [ %prol.iter1573.next, %scalar.ph1467.prol ], [ 0, %scalar.ph1467.preheader ]
  %1183 = getelementptr inbounds [0 x i16], ptr %1091, i64 0, i64 %.08821293.prol
  %1184 = load i16, ptr %1183, align 1, !tbaa !23
  %1185 = getelementptr inbounds [0 x i16], ptr %1181, i64 0, i64 %.08821293.prol
  store i16 %1184, ptr %1185, align 1, !tbaa !23
  %1186 = add nuw i64 %.08821293.prol, 1
  %prol.iter1573.next = add i64 %prol.iter1573, 1
  %prol.iter1573.cmp.not = icmp eq i64 %prol.iter1573.next, %xtraiter1571
  br i1 %prol.iter1573.cmp.not, label %scalar.ph1467.prol.loopexit, label %scalar.ph1467.prol, !llvm.loop !71

scalar.ph1467.prol.loopexit:                      ; preds = %scalar.ph1467.prol, %scalar.ph1467.preheader
  %.08821293.unr = phi i64 [ %.08821293.ph, %scalar.ph1467.preheader ], [ %1186, %scalar.ph1467.prol ]
  %1187 = sub i64 %.08821293.ph, %1180
  %1188 = icmp ugt i64 %1187, -4
  br i1 %1188, label %._crit_edge1296, label %scalar.ph1467

vector.ph1469:                                    ; preds = %.lr.ph1295
  %n.vec1471 = and i64 %1180, -16
  br label %vector.body1473

vector.body1473:                                  ; preds = %vector.body1473, %vector.ph1469
  %index1474 = phi i64 [ 0, %vector.ph1469 ], [ %index.next1477, %vector.body1473 ]
  %1189 = getelementptr inbounds [0 x i16], ptr %1091, i64 0, i64 %index1474
  %1190 = getelementptr inbounds i8, ptr %1189, i64 16
  %wide.load1475 = load <8 x i16>, ptr %1189, align 1, !tbaa !23
  %wide.load1476 = load <8 x i16>, ptr %1190, align 1, !tbaa !23
  %1191 = getelementptr inbounds [0 x i16], ptr %1181, i64 0, i64 %index1474
  %1192 = getelementptr inbounds i8, ptr %1191, i64 16
  store <8 x i16> %wide.load1475, ptr %1191, align 1, !tbaa !23
  store <8 x i16> %wide.load1476, ptr %1192, align 1, !tbaa !23
  %index.next1477 = add nuw i64 %index1474, 16
  %1193 = icmp eq i64 %index.next1477, %n.vec1471
  br i1 %1193, label %middle.block1466, label %vector.body1473, !llvm.loop !72

middle.block1466:                                 ; preds = %vector.body1473
  %cmp.n1478 = icmp eq i64 %1180, %n.vec1471
  br i1 %cmp.n1478, label %._crit_edge1296, label %scalar.ph1467.preheader

._crit_edge1296:                                  ; preds = %scalar.ph1467.prol.loopexit, %scalar.ph1467, %middle.block1466, %1179
  %1194 = getelementptr inbounds i8, ptr %.0899, i64 12
  %1195 = load i16, ptr %1194, align 1, !tbaa !17
  %1196 = getelementptr inbounds i8, ptr %22, i64 12
  store i16 %1195, ptr %1196, align 1, !tbaa !17
  %1197 = getelementptr inbounds i8, ptr %.0899, i64 14
  %1198 = load i16, ptr %1197, align 1, !tbaa !17
  %1199 = getelementptr inbounds i8, ptr %22, i64 14
  store i16 %1198, ptr %1199, align 1, !tbaa !17
  %1200 = add i64 %1180, -1
  %1201 = call ptr @page_node(ptr noundef %22, i64 noundef %1200) #12
  %1202 = call ptr @page_node(ptr noundef nonnull %.0899, i64 noundef %1200) #12
  %1203 = getelementptr inbounds i8, ptr %15, i64 8
  %1204 = load i32, ptr %1203, align 8, !tbaa !73
  %1205 = load i16, ptr %1197, align 1, !tbaa !17
  %1206 = zext i16 %1205 to i32
  %1207 = add i32 %1204, -20
  %1208 = sub i32 %1207, %1206
  %1209 = zext i32 %1208 to i64
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %1201, ptr align 1 %1202, i64 %1209, i1 false)
  %1210 = icmp ugt i64 %.6925, %35
  %1211 = load i8, ptr %18, align 1, !tbaa !17
  %1212 = sext i8 %1211 to i64
  %1213 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %1212
  br i1 %1210, label %1230, label %1231

scalar.ph1467:                                    ; preds = %scalar.ph1467.prol.loopexit, %scalar.ph1467
  %.08821293 = phi i64 [ %1229, %scalar.ph1467 ], [ %.08821293.unr, %scalar.ph1467.prol.loopexit ]
  %1214 = getelementptr inbounds [0 x i16], ptr %1091, i64 0, i64 %.08821293
  %1215 = load i16, ptr %1214, align 1, !tbaa !23
  %1216 = getelementptr inbounds [0 x i16], ptr %1181, i64 0, i64 %.08821293
  store i16 %1215, ptr %1216, align 1, !tbaa !23
  %1217 = add nuw i64 %.08821293, 1
  %1218 = getelementptr inbounds [0 x i16], ptr %1091, i64 0, i64 %1217
  %1219 = load i16, ptr %1218, align 1, !tbaa !23
  %1220 = getelementptr inbounds [0 x i16], ptr %1181, i64 0, i64 %1217
  store i16 %1219, ptr %1220, align 1, !tbaa !23
  %1221 = add nuw i64 %.08821293, 2
  %1222 = getelementptr inbounds [0 x i16], ptr %1091, i64 0, i64 %1221
  %1223 = load i16, ptr %1222, align 1, !tbaa !23
  %1224 = getelementptr inbounds [0 x i16], ptr %1181, i64 0, i64 %1221
  store i16 %1223, ptr %1224, align 1, !tbaa !23
  %1225 = add nuw i64 %.08821293, 3
  %1226 = getelementptr inbounds [0 x i16], ptr %1091, i64 0, i64 %1225
  %1227 = load i16, ptr %1226, align 1, !tbaa !23
  %1228 = getelementptr inbounds [0 x i16], ptr %1181, i64 0, i64 %1225
  store i16 %1227, ptr %1228, align 1, !tbaa !23
  %1229 = add nuw i64 %.08821293, 4
  %exitcond1337.not.3 = icmp eq i64 %1229, %1180
  br i1 %exitcond1337.not.3, label %._crit_edge1296, label %scalar.ph1467, !llvm.loop !82

1230:                                             ; preds = %._crit_edge1296
  store ptr %22, ptr %1213, align 8, !tbaa !18
  br label %.thread1234

1231:                                             ; preds = %._crit_edge1296
  store ptr %79, ptr %1213, align 8, !tbaa !18
  %1232 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %.3917
  %1233 = load i16, ptr %1232, align 2, !tbaa !23
  %1234 = add i16 %1233, 1
  store i16 %1234, ptr %1232, align 2, !tbaa !23
  %1235 = getelementptr inbounds [32 x ptr], ptr %156, i64 0, i64 %.3917
  %1236 = load ptr, ptr %1235, align 8, !tbaa !18
  %1237 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %.3917
  %1238 = load ptr, ptr %1237, align 8, !tbaa !18
  %.not1108 = icmp eq ptr %1236, %1238
  br i1 %.not1108, label %.thread1234, label %1239

1239:                                             ; preds = %1231
  %1240 = zext i16 %1234 to i64
  %1241 = call i64 @page_numkeys(ptr noundef %1238) #12
  %.not1109 = icmp ugt i64 %1241, %1240
  %.not11101297 = icmp slt i64 %.3917, 0
  %or.cond1318 = select i1 %.not1109, i1 true, i1 %.not11101297
  br i1 %or.cond1318, label %.thread1234, label %.lr.ph1299.preheader

.lr.ph1299.preheader:                             ; preds = %1239
  %1242 = add nuw nsw i64 %.3917, 1
  %min.iters.check1484 = icmp ult i64 %.3917, 5
  %1243 = sub i64 %6, %155
  %diff.check1480 = icmp ult i64 %1243, 32
  %or.cond1553 = or i1 %min.iters.check1484, %diff.check1480
  br i1 %or.cond1553, label %.lr.ph1299.preheader1563, label %vector.ph1485

vector.ph1485:                                    ; preds = %.lr.ph1299.preheader
  %n.vec1487 = and i64 %1242, 9223372036854775804
  br label %vector.body1489

vector.body1489:                                  ; preds = %vector.body1489, %vector.ph1485
  %index1490 = phi i64 [ 0, %vector.ph1485 ], [ %index.next1495, %vector.body1489 ]
  %1244 = getelementptr inbounds [32 x ptr], ptr %156, i64 0, i64 %index1490
  %1245 = getelementptr inbounds i8, ptr %1244, i64 16
  %wide.load1491 = load <2 x ptr>, ptr %1244, align 8, !tbaa !18
  %wide.load1492 = load <2 x ptr>, ptr %1245, align 8, !tbaa !18
  %1246 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %index1490
  %1247 = getelementptr inbounds i8, ptr %1246, i64 16
  store <2 x ptr> %wide.load1491, ptr %1246, align 8, !tbaa !18
  store <2 x ptr> %wide.load1492, ptr %1247, align 8, !tbaa !18
  %1248 = getelementptr inbounds [32 x i16], ptr %161, i64 0, i64 %index1490
  %1249 = getelementptr inbounds i8, ptr %1248, i64 4
  %wide.load1493 = load <2 x i16>, ptr %1248, align 2, !tbaa !23
  %wide.load1494 = load <2 x i16>, ptr %1249, align 2, !tbaa !23
  %1250 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %index1490
  %1251 = getelementptr inbounds i8, ptr %1250, i64 4
  store <2 x i16> %wide.load1493, ptr %1250, align 2, !tbaa !23
  store <2 x i16> %wide.load1494, ptr %1251, align 2, !tbaa !23
  %index.next1495 = add nuw i64 %index1490, 4
  %1252 = icmp eq i64 %index.next1495, %n.vec1487
  br i1 %1252, label %middle.block1482, label %vector.body1489, !llvm.loop !83

middle.block1482:                                 ; preds = %vector.body1489
  %cmp.n1496 = icmp eq i64 %1242, %n.vec1487
  br i1 %cmp.n1496, label %.thread1234, label %.lr.ph1299.preheader1563

.lr.ph1299.preheader1563:                         ; preds = %middle.block1482, %.lr.ph1299.preheader
  %.08811298.ph = phi i64 [ 0, %.lr.ph1299.preheader ], [ %n.vec1487, %middle.block1482 ]
  %1253 = and i64 %.3917, 1
  %lcmp.mod1575.not.not = icmp eq i64 %1253, 0
  br i1 %lcmp.mod1575.not.not, label %.lr.ph1299.prol, label %.lr.ph1299.prol.loopexit

.lr.ph1299.prol:                                  ; preds = %.lr.ph1299.preheader1563
  %1254 = getelementptr inbounds [32 x ptr], ptr %156, i64 0, i64 %.08811298.ph
  %1255 = load ptr, ptr %1254, align 8, !tbaa !18
  %1256 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %.08811298.ph
  store ptr %1255, ptr %1256, align 8, !tbaa !18
  %1257 = getelementptr inbounds [32 x i16], ptr %161, i64 0, i64 %.08811298.ph
  %1258 = load i16, ptr %1257, align 2, !tbaa !23
  %1259 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %.08811298.ph
  store i16 %1258, ptr %1259, align 2, !tbaa !23
  %1260 = or disjoint i64 %.08811298.ph, 1
  br label %.lr.ph1299.prol.loopexit

.lr.ph1299.prol.loopexit:                         ; preds = %.lr.ph1299.prol, %.lr.ph1299.preheader1563
  %.08811298.unr = phi i64 [ %.08811298.ph, %.lr.ph1299.preheader1563 ], [ %1260, %.lr.ph1299.prol ]
  %1261 = icmp eq i64 %.3917, %.08811298.ph
  br i1 %1261, label %.thread1234, label %.lr.ph1299

.lr.ph1299:                                       ; preds = %.lr.ph1299.prol.loopexit, %.lr.ph1299
  %.08811298 = phi i64 [ %1275, %.lr.ph1299 ], [ %.08811298.unr, %.lr.ph1299.prol.loopexit ]
  %1262 = getelementptr inbounds [32 x ptr], ptr %156, i64 0, i64 %.08811298
  %1263 = load ptr, ptr %1262, align 8, !tbaa !18
  %1264 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %.08811298
  store ptr %1263, ptr %1264, align 8, !tbaa !18
  %1265 = getelementptr inbounds [32 x i16], ptr %161, i64 0, i64 %.08811298
  %1266 = load i16, ptr %1265, align 2, !tbaa !23
  %1267 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %.08811298
  store i16 %1266, ptr %1267, align 2, !tbaa !23
  %1268 = add nuw nsw i64 %.08811298, 1
  %1269 = getelementptr inbounds [32 x ptr], ptr %156, i64 0, i64 %1268
  %1270 = load ptr, ptr %1269, align 8, !tbaa !18
  %1271 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %1268
  store ptr %1270, ptr %1271, align 8, !tbaa !18
  %1272 = getelementptr inbounds [32 x i16], ptr %161, i64 0, i64 %1268
  %1273 = load i16, ptr %1272, align 2, !tbaa !23
  %1274 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %1268
  store i16 %1273, ptr %1274, align 2, !tbaa !23
  %1275 = add nuw nsw i64 %.08811298, 2
  %exitcond1338.not.1 = icmp eq i64 %1268, %.3917
  br i1 %exitcond1338.not.1, label %.thread1234, label %.lr.ph1299, !llvm.loop !84

1276:                                             ; preds = %1084
  %.not1095 = icmp ugt i64 %.6925, %35
  br i1 %.not1095, label %.thread1234, label %1277

1277:                                             ; preds = %1276
  %1278 = load i8, ptr %18, align 1, !tbaa !17
  %1279 = sext i8 %1278 to i64
  %1280 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %1279
  store ptr %79, ptr %1280, align 8, !tbaa !18
  %1281 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %.3917
  %1282 = load i16, ptr %1281, align 2, !tbaa !23
  %1283 = add i16 %1282, 1
  store i16 %1283, ptr %1281, align 2, !tbaa !23
  %1284 = getelementptr inbounds [32 x ptr], ptr %156, i64 0, i64 %.3917
  %1285 = load ptr, ptr %1284, align 8, !tbaa !18
  %1286 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %.3917
  %1287 = load ptr, ptr %1286, align 8, !tbaa !18
  %.not1096 = icmp eq ptr %1285, %1287
  br i1 %.not1096, label %.thread1234, label %1288

1288:                                             ; preds = %1277
  %1289 = zext i16 %1283 to i64
  %1290 = call i64 @page_numkeys(ptr noundef %1287) #12
  %.not1097 = icmp ugt i64 %1290, %1289
  %.not10981300 = icmp slt i64 %.3917, 0
  %or.cond1319 = select i1 %.not1097, i1 true, i1 %.not10981300
  br i1 %or.cond1319, label %.thread1234, label %.lr.ph1302.preheader

.lr.ph1302.preheader:                             ; preds = %1288
  %1291 = add nuw nsw i64 %.3917, 1
  %min.iters.check1502 = icmp ult i64 %.3917, 5
  %1292 = sub i64 %6, %155
  %diff.check1498 = icmp ult i64 %1292, 32
  %or.cond1554 = or i1 %min.iters.check1502, %diff.check1498
  br i1 %or.cond1554, label %.lr.ph1302.preheader1561, label %vector.ph1503

vector.ph1503:                                    ; preds = %.lr.ph1302.preheader
  %n.vec1505 = and i64 %1291, 9223372036854775804
  br label %vector.body1507

vector.body1507:                                  ; preds = %vector.body1507, %vector.ph1503
  %index1508 = phi i64 [ 0, %vector.ph1503 ], [ %index.next1513, %vector.body1507 ]
  %1293 = getelementptr inbounds [32 x ptr], ptr %156, i64 0, i64 %index1508
  %1294 = getelementptr inbounds i8, ptr %1293, i64 16
  %wide.load1509 = load <2 x ptr>, ptr %1293, align 8, !tbaa !18
  %wide.load1510 = load <2 x ptr>, ptr %1294, align 8, !tbaa !18
  %1295 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %index1508
  %1296 = getelementptr inbounds i8, ptr %1295, i64 16
  store <2 x ptr> %wide.load1509, ptr %1295, align 8, !tbaa !18
  store <2 x ptr> %wide.load1510, ptr %1296, align 8, !tbaa !18
  %1297 = getelementptr inbounds [32 x i16], ptr %161, i64 0, i64 %index1508
  %1298 = getelementptr inbounds i8, ptr %1297, i64 4
  %wide.load1511 = load <2 x i16>, ptr %1297, align 2, !tbaa !23
  %wide.load1512 = load <2 x i16>, ptr %1298, align 2, !tbaa !23
  %1299 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %index1508
  %1300 = getelementptr inbounds i8, ptr %1299, i64 4
  store <2 x i16> %wide.load1511, ptr %1299, align 2, !tbaa !23
  store <2 x i16> %wide.load1512, ptr %1300, align 2, !tbaa !23
  %index.next1513 = add nuw i64 %index1508, 4
  %1301 = icmp eq i64 %index.next1513, %n.vec1505
  br i1 %1301, label %middle.block1500, label %vector.body1507, !llvm.loop !85

middle.block1500:                                 ; preds = %vector.body1507
  %cmp.n1514 = icmp eq i64 %1291, %n.vec1505
  br i1 %cmp.n1514, label %.thread1234, label %.lr.ph1302.preheader1561

.lr.ph1302.preheader1561:                         ; preds = %middle.block1500, %.lr.ph1302.preheader
  %.08801301.ph = phi i64 [ 0, %.lr.ph1302.preheader ], [ %n.vec1505, %middle.block1500 ]
  %1302 = and i64 %.3917, 1
  %lcmp.mod1578.not.not = icmp eq i64 %1302, 0
  br i1 %lcmp.mod1578.not.not, label %.lr.ph1302.prol, label %.lr.ph1302.prol.loopexit

.lr.ph1302.prol:                                  ; preds = %.lr.ph1302.preheader1561
  %1303 = getelementptr inbounds [32 x ptr], ptr %156, i64 0, i64 %.08801301.ph
  %1304 = load ptr, ptr %1303, align 8, !tbaa !18
  %1305 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %.08801301.ph
  store ptr %1304, ptr %1305, align 8, !tbaa !18
  %1306 = getelementptr inbounds [32 x i16], ptr %161, i64 0, i64 %.08801301.ph
  %1307 = load i16, ptr %1306, align 2, !tbaa !23
  %1308 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %.08801301.ph
  store i16 %1307, ptr %1308, align 2, !tbaa !23
  %1309 = or disjoint i64 %.08801301.ph, 1
  br label %.lr.ph1302.prol.loopexit

.lr.ph1302.prol.loopexit:                         ; preds = %.lr.ph1302.prol, %.lr.ph1302.preheader1561
  %.08801301.unr = phi i64 [ %.08801301.ph, %.lr.ph1302.preheader1561 ], [ %1309, %.lr.ph1302.prol ]
  %1310 = icmp eq i64 %.3917, %.08801301.ph
  br i1 %1310, label %.thread1234, label %.lr.ph1302

.lr.ph1302:                                       ; preds = %.lr.ph1302.prol.loopexit, %.lr.ph1302
  %.08801301 = phi i64 [ %1324, %.lr.ph1302 ], [ %.08801301.unr, %.lr.ph1302.prol.loopexit ]
  %1311 = getelementptr inbounds [32 x ptr], ptr %156, i64 0, i64 %.08801301
  %1312 = load ptr, ptr %1311, align 8, !tbaa !18
  %1313 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %.08801301
  store ptr %1312, ptr %1313, align 8, !tbaa !18
  %1314 = getelementptr inbounds [32 x i16], ptr %161, i64 0, i64 %.08801301
  %1315 = load i16, ptr %1314, align 2, !tbaa !23
  %1316 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %.08801301
  store i16 %1315, ptr %1316, align 2, !tbaa !23
  %1317 = add nuw nsw i64 %.08801301, 1
  %1318 = getelementptr inbounds [32 x ptr], ptr %156, i64 0, i64 %1317
  %1319 = load ptr, ptr %1318, align 8, !tbaa !18
  %1320 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %1317
  store ptr %1319, ptr %1320, align 8, !tbaa !18
  %1321 = getelementptr inbounds [32 x i16], ptr %161, i64 0, i64 %1317
  %1322 = load i16, ptr %1321, align 2, !tbaa !23
  %1323 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %1317
  store i16 %1322, ptr %1323, align 2, !tbaa !23
  %1324 = add nuw nsw i64 %.08801301, 2
  %exitcond1339.not.1 = icmp eq i64 %1317, %.3917
  br i1 %exitcond1339.not.1, label %.thread1234, label %.lr.ph1302, !llvm.loop !86

.thread1234:                                      ; preds = %.lr.ph1299.prol.loopexit, %.lr.ph1299, %.lr.ph1302.prol.loopexit, %.lr.ph1302, %1082, %.lr.ph1307.prol.loopexit, %.lr.ph1307, %middle.block1482, %middle.block1500, %middle.block1517, %.preheader, %1230, %1239, %1231, %1049, %1078, %1277, %1288, %1276, %1041
  %.39171231 = phi i64 [ %.39171232, %1041 ], [ %.3917, %1288 ], [ %.3917, %1277 ], [ %.3917, %1276 ], [ %.39171232, %1078 ], [ %.39171232, %1049 ], [ %.3917, %1231 ], [ %.3917, %1239 ], [ %.3917, %1230 ], [ %.39171232, %.preheader ], [ %.39171232, %middle.block1517 ], [ %.3917, %middle.block1500 ], [ %.3917, %middle.block1482 ], [ %.39171232, %.lr.ph1307 ], [ %.39171232, %.lr.ph1307.prol.loopexit ], [ %.39171232, %1082 ], [ %.3917, %.lr.ph1302 ], [ %.3917, %.lr.ph1302.prol.loopexit ], [ %.3917, %.lr.ph1299 ], [ %.3917, %.lr.ph1299.prol.loopexit ]
  %1325 = call i64 @page_numkeys(ptr noundef %22) #12
  %1326 = load ptr, ptr %12, align 8, !tbaa !5
  %1327 = getelementptr inbounds i8, ptr %1326, i64 120
  %1328 = load ptr, ptr %1327, align 8, !tbaa !57
  %1329 = call i64 @cursor_dbi(ptr noundef %0) #12
  %1330 = getelementptr inbounds ptr, ptr %1328, i64 %1329
  %.08791312 = load ptr, ptr %1330, align 8, !tbaa !18
  %.not11191313 = icmp eq ptr %.08791312, null
  br i1 %.not11191313, label %._crit_edge1316, label %.lr.ph1315

.lr.ph1315:                                       ; preds = %.thread1234
  %.not1121 = icmp eq i16 %.0898.shrunk, 0
  %1331 = zext i16 %.0898.shrunk to i64
  %1332 = zext i1 %259 to i64
  %1333 = add i64 %1325, %1332
  %1334 = lshr i32 %4, 18
  %1335 = trunc nuw nsw i32 %1334 to i16
  %1336 = and i16 %1335, 1
  %1337 = xor i16 %1336, 1
  %1338 = trunc i64 %1325 to i16
  %1339 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %.39171231
  %1340 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %.39171231
  %1341 = add nuw nsw i64 %1331, 1
  %n.vec1535 = and i64 %1341, 131070
  %ind.end1536 = sub nsw i64 %1331, %n.vec1535
  %cmp.n1547 = icmp eq i64 %1341, %n.vec1535
  br label %1344

._crit_edge1316:                                  ; preds = %1447, %.thread1234
  %1342 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 26), align 2, !tbaa !25
  %1343 = icmp ugt i8 %1342, 5
  br i1 %1343, label %1449, label %.thread1219, !prof !22

1344:                                             ; preds = %.lr.ph1315, %1447
  %.08791314 = phi ptr [ %.08791312, %.lr.ph1315 ], [ %.0879, %1447 ]
  %1345 = load i8, ptr %17, align 4, !tbaa !17
  %1346 = and i8 %1345, 1
  %.not1120 = icmp eq i8 %1346, 0
  br i1 %.not1120, label %1350, label %1347

1347:                                             ; preds = %1344
  %1348 = getelementptr inbounds i8, ptr %.08791314, i64 40
  %1349 = load ptr, ptr %1348, align 8, !tbaa !87
  br label %1350

1350:                                             ; preds = %1344, %1347
  %1351 = phi ptr [ %1349, %1347 ], [ %.08791314, %1344 ]
  %1352 = call zeroext i1 @is_pointed(ptr noundef %1351) #12
  %1353 = icmp ne ptr %1351, %0
  %or.cond1167.not = and i1 %1353, %1352
  br i1 %or.cond1167.not, label %1354, label %1447

1354:                                             ; preds = %1350
  br i1 %.not1121, label %._crit_edge1369, label %1355

._crit_edge1369:                                  ; preds = %1354
  %.phi.trans.insert1370 = getelementptr inbounds i8, ptr %1351, i64 5
  %.pre1371 = load i8, ptr %.phi.trans.insert1370, align 1, !tbaa !17
  br label %1378

1355:                                             ; preds = %1354
  %1356 = getelementptr inbounds i8, ptr %1351, i64 48
  %1357 = load ptr, ptr %1356, align 8, !tbaa !18
  %.not1122 = icmp eq ptr %1357, %22
  br i1 %.not1122, label %vector.ph1533, label %1447

vector.ph1533:                                    ; preds = %1355
  %1358 = getelementptr inbounds i8, ptr %1351, i64 304
  %invariant.gep = getelementptr i8, ptr %1358, i64 -2
  %invariant.gep1595 = getelementptr i8, ptr %1358, i64 -2
  %invariant.gep1597 = getelementptr i8, ptr %1356, i64 -8
  %invariant.gep1599 = getelementptr i8, ptr %1356, i64 -8
  br label %vector.body1538

vector.body1538:                                  ; preds = %vector.body1538, %vector.ph1533
  %index1539 = phi i64 [ 0, %vector.ph1533 ], [ %index.next1546, %vector.body1538 ]
  %offset.idx1540 = sub i64 %1331, %index1539
  %gep = getelementptr [32 x i16], ptr %invariant.gep, i64 0, i64 %offset.idx1540
  %wide.load1541 = load <2 x i16>, ptr %gep, align 2, !tbaa !23
  %1359 = add nuw nsw i64 %offset.idx1540, 1
  %gep1596 = getelementptr [32 x i16], ptr %invariant.gep1595, i64 0, i64 %1359
  store <2 x i16> %wide.load1541, ptr %gep1596, align 2, !tbaa !23
  %gep1598 = getelementptr [32 x ptr], ptr %invariant.gep1597, i64 0, i64 %offset.idx1540
  %wide.load1543 = load <2 x ptr>, ptr %gep1598, align 8, !tbaa !18
  %gep1600 = getelementptr [32 x ptr], ptr %invariant.gep1599, i64 0, i64 %1359
  store <2 x ptr> %wide.load1543, ptr %gep1600, align 8, !tbaa !18
  %index.next1546 = add nuw i64 %index1539, 2
  %1360 = icmp eq i64 %index.next1546, %n.vec1535
  br i1 %1360, label %middle.block1530, label %vector.body1538, !llvm.loop !88

middle.block1530:                                 ; preds = %vector.body1538
  br i1 %cmp.n1547, label %.loopexit1548, label %scalar.ph1531

.loopexit1548:                                    ; preds = %scalar.ph1531, %middle.block1530
  %1361 = load i16, ptr %1358, align 8, !tbaa !23
  %1362 = zext i16 %1361 to i64
  %1363 = icmp ule i64 %1333, %1362
  %1364 = zext i1 %1363 to i16
  store i16 %1364, ptr %1358, align 8, !tbaa !23
  %1365 = load ptr, ptr %16, align 8, !tbaa !18
  store ptr %1365, ptr %1356, align 8, !tbaa !18
  %1366 = getelementptr inbounds i8, ptr %1351, i64 5
  %1367 = load i8, ptr %1366, align 1, !tbaa !17
  %1368 = add i8 %1367, 1
  store i8 %1368, ptr %1366, align 1, !tbaa !17
  br label %1378

scalar.ph1531:                                    ; preds = %middle.block1530, %scalar.ph1531
  %.08771308 = phi i64 [ %1376, %scalar.ph1531 ], [ %ind.end1536, %middle.block1530 ]
  %1369 = getelementptr inbounds [32 x i16], ptr %1358, i64 0, i64 %.08771308
  %1370 = load i16, ptr %1369, align 2, !tbaa !23
  %1371 = add nuw nsw i64 %.08771308, 1
  %1372 = getelementptr inbounds [32 x i16], ptr %1358, i64 0, i64 %1371
  store i16 %1370, ptr %1372, align 2, !tbaa !23
  %1373 = getelementptr inbounds [32 x ptr], ptr %1356, i64 0, i64 %.08771308
  %1374 = load ptr, ptr %1373, align 8, !tbaa !18
  %1375 = getelementptr inbounds [32 x ptr], ptr %1356, i64 0, i64 %1371
  store ptr %1374, ptr %1375, align 8, !tbaa !18
  %1376 = add nsw i64 %.08771308, -1
  %1377 = icmp sgt i64 %.08771308, 0
  br i1 %1377, label %scalar.ph1531, label %.loopexit1548, !llvm.loop !89

1378:                                             ; preds = %._crit_edge1369, %.loopexit1548
  %1379 = phi i8 [ %.pre1371, %._crit_edge1369 ], [ %1368, %.loopexit1548 ]
  %1380 = load i8, ptr %18, align 1, !tbaa !17
  %.not1123 = icmp slt i8 %1379, %1380
  br i1 %.not1123, label %1419, label %1381

1381:                                             ; preds = %1378
  %1382 = getelementptr inbounds i8, ptr %1351, i64 48
  %1383 = sext i8 %1380 to i64
  %1384 = getelementptr inbounds [32 x ptr], ptr %1382, i64 0, i64 %1383
  %1385 = load ptr, ptr %1384, align 8, !tbaa !18
  %1386 = icmp ne ptr %1385, %22
  %brmerge1169 = or i1 %259, %1386
  br i1 %brmerge1169, label %1419, label %1387

1387:                                             ; preds = %1381
  %1388 = getelementptr inbounds i8, ptr %1351, i64 304
  %1389 = getelementptr inbounds [32 x i16], ptr %1388, i64 0, i64 %1383
  %1390 = load i16, ptr %1389, align 2, !tbaa !23
  %.not1124 = icmp ult i16 %1390, %34
  br i1 %.not1124, label %1393, label %1391

1391:                                             ; preds = %1387
  %1392 = add i16 %1390, %1337
  store i16 %1392, ptr %1389, align 2, !tbaa !23
  %.pre1372 = load i8, ptr %18, align 1, !tbaa !17
  %.phi.trans.insert1373 = sext i8 %.pre1372 to i64
  %.phi.trans.insert1374 = getelementptr inbounds [32 x i16], ptr %1388, i64 0, i64 %.phi.trans.insert1373
  %.pre1375 = load i16, ptr %.phi.trans.insert1374, align 2, !tbaa !23
  br label %1393

1393:                                             ; preds = %1391, %1387
  %.pre-phi1383 = phi i64 [ %.phi.trans.insert1373, %1391 ], [ %1383, %1387 ]
  %1394 = phi i16 [ %.pre1375, %1391 ], [ %1390, %1387 ]
  %1395 = zext i16 %1394 to i64
  %.not1126 = icmp ugt i64 %1325, %1395
  br i1 %.not1126, label %.loopexit, label %1396

1396:                                             ; preds = %1393
  %1397 = getelementptr inbounds [32 x ptr], ptr %1382, i64 0, i64 %.pre-phi1383
  store ptr %79, ptr %1397, align 8, !tbaa !18
  %1398 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %1399 = and i8 %1398, 1
  %.not1127 = icmp ne i8 %1399, 0
  %.pre1376 = load i8, ptr %18, align 1, !tbaa !17
  %.phi.trans.insert1378 = sext i8 %.pre1376 to i64
  %.phi.trans.insert1379 = getelementptr inbounds [32 x i16], ptr %1388, i64 0, i64 %.phi.trans.insert1378
  %.pre1380 = load i16, ptr %.phi.trans.insert1379, align 2, !tbaa !23
  %1400 = zext i16 %.pre1380 to i64
  %.not1128 = icmp ugt i64 %1325, %1400
  %or.cond1413 = select i1 %.not1127, i1 %.not1128, i1 false
  br i1 %or.cond1413, label %1401, label %._crit_edge1377, !prof !45

1401:                                             ; preds = %1396
  %1402 = load ptr, ptr %12, align 8, !tbaa !5
  %1403 = getelementptr inbounds i8, ptr %1402, i64 80
  %1404 = load ptr, ptr %1403, align 8, !tbaa !11
  call void @mdbx_assert_fail(ptr noundef %1404, ptr noundef nonnull @.str.102, ptr noundef nonnull @__func__.page_split, i32 noundef 1481) #11
  unreachable

._crit_edge1377:                                  ; preds = %1396
  %1405 = getelementptr inbounds [32 x i16], ptr %1388, i64 0, i64 %.phi.trans.insert1378
  %1406 = sub i16 %.pre1380, %1338
  store i16 %1406, ptr %1405, align 2, !tbaa !23
  %1407 = load i8, ptr %18, align 1, !tbaa !17
  %1408 = icmp sgt i8 %1407, 0
  br i1 %1408, label %.lr.ph1311, label %.loopexit

.lr.ph1311:                                       ; preds = %._crit_edge1377, %.lr.ph1311
  %.08761309 = phi i64 [ %1415, %.lr.ph1311 ], [ 0, %._crit_edge1377 ]
  %1409 = getelementptr inbounds [32 x i16], ptr %161, i64 0, i64 %.08761309
  %1410 = load i16, ptr %1409, align 2, !tbaa !23
  %1411 = getelementptr inbounds [32 x i16], ptr %1388, i64 0, i64 %.08761309
  store i16 %1410, ptr %1411, align 2, !tbaa !23
  %1412 = getelementptr inbounds [32 x ptr], ptr %156, i64 0, i64 %.08761309
  %1413 = load ptr, ptr %1412, align 8, !tbaa !18
  %1414 = getelementptr inbounds [32 x ptr], ptr %1382, i64 0, i64 %.08761309
  store ptr %1413, ptr %1414, align 8, !tbaa !18
  %1415 = add nuw nsw i64 %.08761309, 1
  %1416 = load i8, ptr %18, align 1, !tbaa !17
  %1417 = sext i8 %1416 to i64
  %1418 = icmp slt i64 %1415, %1417
  br i1 %1418, label %.lr.ph1311, label %.loopexit, !llvm.loop !90

1419:                                             ; preds = %1381, %1378
  %1420 = sext i8 %1379 to i64
  %.not1129 = icmp sgt i64 %.39171231, %1420
  %or.cond1262 = select i1 %666, i1 true, i1 %.not1129
  br i1 %or.cond1262, label %.loopexit, label %1421

1421:                                             ; preds = %1419
  %1422 = getelementptr inbounds i8, ptr %1351, i64 48
  %1423 = getelementptr inbounds [32 x ptr], ptr %1422, i64 0, i64 %.39171231
  %1424 = load ptr, ptr %1423, align 8, !tbaa !18
  %1425 = load ptr, ptr %1339, align 8, !tbaa !18
  %1426 = icmp eq ptr %1424, %1425
  br i1 %1426, label %1427, label %.loopexit

1427:                                             ; preds = %1421
  %1428 = getelementptr inbounds i8, ptr %1351, i64 304
  %1429 = getelementptr inbounds [32 x i16], ptr %1428, i64 0, i64 %.39171231
  %1430 = load i16, ptr %1429, align 2, !tbaa !23
  %1431 = load i16, ptr %1340, align 2, !tbaa !23
  %.not1130 = icmp ult i16 %1430, %1431
  br i1 %.not1130, label %.loopexit, label %1432

1432:                                             ; preds = %1427
  %1433 = add i16 %1430, 1
  store i16 %1433, ptr %1429, align 2, !tbaa !23
  br label %.loopexit

.loopexit:                                        ; preds = %.lr.ph1311, %._crit_edge1377, %1419, %1421, %1427, %1432, %1393
  %1434 = call zeroext i1 @inner_pointed(ptr noundef nonnull %1351) #12
  br i1 %1434, label %1435, label %1447

1435:                                             ; preds = %.loopexit
  %1436 = call zeroext i1 @is_leaf(ptr noundef %22) #12
  br i1 %1436, label %1437, label %1447

1437:                                             ; preds = %1435
  %1438 = getelementptr inbounds i8, ptr %1351, i64 48
  %1439 = load i8, ptr %18, align 1, !tbaa !17
  %1440 = sext i8 %1439 to i64
  %1441 = getelementptr inbounds [32 x ptr], ptr %1438, i64 0, i64 %1440
  %1442 = load ptr, ptr %1441, align 8, !tbaa !18
  %1443 = getelementptr inbounds i8, ptr %1351, i64 304
  %1444 = getelementptr inbounds [32 x i16], ptr %1443, i64 0, i64 %1440
  %1445 = load i16, ptr %1444, align 2, !tbaa !23
  %1446 = zext i16 %1445 to i32
  call void @cursor_inner_refresh(ptr noundef nonnull %1351, ptr noundef %1442, i32 noundef %1446)
  br label %1447

1447:                                             ; preds = %.loopexit, %1435, %1437, %1355, %1350
  %1448 = getelementptr inbounds i8, ptr %.08791314, i64 368
  %.0879 = load ptr, ptr %1448, align 8, !tbaa !18
  %.not1119 = icmp eq ptr %.0879, null
  br i1 %.not1119, label %._crit_edge1316, label %1344, !llvm.loop !91

1449:                                             ; preds = %._crit_edge1316
  %1450 = getelementptr inbounds i8, ptr %22, i64 16
  %1451 = load i32, ptr %1450, align 1, !tbaa !26
  %1452 = call i64 @page_room(ptr noundef %22) #12
  %1453 = getelementptr inbounds i8, ptr %79, i64 16
  %1454 = load i32, ptr %1453, align 1, !tbaa !26
  %1455 = call i64 @page_room(ptr noundef %79) #12
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 6, ptr noundef nonnull @__func__.page_split, i32 noundef 1495, ptr noundef nonnull @.str.103, i32 noundef %1451, i64 noundef %1452, i32 noundef %1454, i64 noundef %1455) #10
  br label %.thread1219

.thread1219:                                      ; preds = %1155, %786, %790, %788, %734, %.thread1215, %1078, %904, %._crit_edge1316, %1449, %981, %933
  %.17 = phi i32 [ %.12, %981 ], [ 0, %1449 ], [ 0, %._crit_edge1316 ], [ %938, %933 ], [ %.10, %904 ], [ %1079, %1078 ], [ -30779, %788 ], [ -30779, %790 ], [ %787, %786 ], [ %735, %734 ], [ %709, %.thread1215 ], [ %.15, %1155 ]
  %.not1131 = icmp eq ptr %.0899, null
  br i1 %.not1131, label %1457, label %1456

1456:                                             ; preds = %.thread1219
  call void @page_shadow_release(ptr noundef %15, ptr noundef nonnull %.0899, i64 noundef 1) #10
  br label %1457

1457:                                             ; preds = %1456, %.thread1219
  %.not1132 = icmp eq i32 %.17, 0
  br i1 %.not1132, label %1462, label %.thread1253, !prof !42

.thread1253:                                      ; preds = %95, %486, %484, %482, %131, %143, %1457
  %.1712521256 = phi i32 [ %.17, %1457 ], [ %485, %484 ], [ %483, %482 ], [ 12, %486 ], [ %98, %95 ], [ %144, %143 ], [ %130, %131 ]
  %1458 = load ptr, ptr %12, align 8, !tbaa !5
  %1459 = getelementptr inbounds i8, ptr %1458, i64 4
  %1460 = load i32, ptr %1459, align 4, !tbaa !92
  %1461 = or i32 %1460, 2
  store i32 %1461, ptr %1459, align 4, !tbaa !92
  br label %1488

1462:                                             ; preds = %1457
  %1463 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 25), align 1, !tbaa !19
  %1464 = and i8 %1463, 2
  %.not1133 = icmp eq i8 %1464, 0
  br i1 %.not1133, label %1467, label %1465, !prof !24

1465:                                             ; preds = %1462
  %1466 = call i32 @cursor_validate_updating(ptr noundef %0) #10
  br label %1467

1467:                                             ; preds = %1465, %1462
  %.18 = phi i32 [ %1466, %1465 ], [ 0, %1462 ]
  %1468 = and i32 %4, 65536
  %.not1134 = icmp eq i32 %1468, 0
  br i1 %.not1134, label %1482, label %1469, !prof !24

1469:                                             ; preds = %1467
  %1470 = load i8, ptr %18, align 1, !tbaa !17
  %1471 = sext i8 %1470 to i64
  %1472 = getelementptr inbounds [32 x ptr], ptr %16, i64 0, i64 %1471
  %1473 = load ptr, ptr %1472, align 8, !tbaa !18
  %1474 = getelementptr inbounds [32 x i16], ptr %32, i64 0, i64 %1471
  %1475 = load i16, ptr %1474, align 2, !tbaa !23
  %1476 = zext i16 %1475 to i64
  %1477 = call ptr @page_node(ptr noundef %1473, i64 noundef %1476) #12
  %1478 = call zeroext i8 @node_flags(ptr noundef %1477) #12
  %1479 = and i8 %1478, 1
  %.not1135 = icmp eq i8 %1479, 0
  br i1 %.not1135, label %1480, label %1482

1480:                                             ; preds = %1469
  %1481 = call ptr @node_data(ptr noundef %1477) #12
  store ptr %1481, ptr %2, align 8, !tbaa !46
  br label %1482

1482:                                             ; preds = %1469, %1480, %1467
  %1483 = getelementptr inbounds i8, ptr %15, i64 104
  %1484 = load ptr, ptr %1483, align 8, !tbaa !93
  %1485 = getelementptr inbounds i8, ptr %1484, i64 88
  %1486 = load volatile i64, ptr %1485, align 8, !tbaa !17
  %1487 = add i64 %1486, 1
  store volatile i64 %1487, ptr %1485, align 8, !tbaa !17
  br label %1488

1488:                                             ; preds = %.thread1253, %1482
  %.19 = phi i32 [ %.1712521256, %.thread1253 ], [ %.18, %1482 ]
  %1489 = load i8, ptr getelementptr inbounds (i8, ptr @globals, i64 26), align 2, !tbaa !25
  %1490 = icmp ugt i8 %1489, 4
  br i1 %1490, label %1491, label %1494, !prof !22

1491:                                             ; preds = %1488
  %1492 = getelementptr inbounds i8, ptr %22, i64 16
  %1493 = load i32, ptr %1492, align 1, !tbaa !26
  call void (i32, ptr, i32, ptr, ...) @debug_log(i32 noundef 5, ptr noundef nonnull @__func__.page_split, i32 noundef 1516, ptr noundef nonnull @.str.104, i32 noundef %1493, i32 noundef %.19) #10
  br label %1494

1494:                                             ; preds = %75, %1488, %1491, %38
  %.2 = phi i32 [ %39, %38 ], [ %80, %75 ], [ %.19, %1491 ], [ %.19, %1488 ]
  call void @llvm.lifetime.end.p0(i64 510, ptr nonnull %9) #10
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %8) #10
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %7) #10
  ret i32 %.2
}

declare ptr @mdbx_dump_val(ptr noundef, ptr noundef, i64 noundef) local_unnamed_addr #3

declare { ptr, i32 } @page_new(ptr noundef, i32 noundef) local_unnamed_addr #3

; 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) #5

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

declare i32 @node_add_branch(ptr noundef, i64 noundef, ptr noundef, i32 noundef) local_unnamed_addr #3

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden { ptr, i64 } @get_key(ptr noundef) local_unnamed_addr #1

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden zeroext i1 @is_dupfix_leaf(ptr noundef) local_unnamed_addr #1

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden { ptr, i64 } @page_dupfix_key(ptr noundef, i64 noundef, i64 noundef) local_unnamed_addr #1

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden i64 @branch_size(ptr noundef, ptr noundef) local_unnamed_addr #1

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden ptr @page_dupfix_ptr(ptr noundef, i64 noundef, i64 noundef) local_unnamed_addr #1

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

declare ptr @page_shadow_alloc(ptr noundef, i64 noundef) local_unnamed_addr #3

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden i64 @leaf_size(ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #1

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden i64 @node_ks(ptr noalias noundef) local_unnamed_addr #1

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden i64 @node_ds(ptr noalias noundef) local_unnamed_addr #1

; Function Attrs: inlinehint mustprogress nofree nosync nounwind willreturn memory(none) uwtable
declare hidden i64 @branchless_abs(i64 noundef) local_unnamed_addr #7

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden ptr @node_key(ptr noalias noundef) local_unnamed_addr #1

declare i32 @cursor_sibling_left(ptr noundef) local_unnamed_addr #3

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

declare i32 @node_add_leaf(ptr noundef, i64 noundef, ptr noundef, ptr noundef, i32 noundef) local_unnamed_addr #3

declare i32 @node_add_dupfix(ptr noundef, i64 noundef, ptr noundef) local_unnamed_addr #3

declare i32 @bad_page(ptr noundef, ptr noundef, ...) local_unnamed_addr #3

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden ptr @node_data(ptr noalias noundef) local_unnamed_addr #1

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden zeroext i1 @is_pointed(ptr noundef) local_unnamed_addr #1

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare hidden zeroext i1 @inner_pointed(ptr noundef) local_unnamed_addr #1

; Function Attrs: inlinehint nounwind uwtable
declare hidden void @cursor_inner_refresh(ptr noundef, ptr noundef, i32 noundef) local_unnamed_addr #8

declare void @page_shadow_release(ptr noundef, ptr noundef, i64 noundef) local_unnamed_addr #3

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare i64 @llvm.umax.i64(i64, i64) #9

attributes #0 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #2 = { noreturn "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 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #4 = { nounwind 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 = { mustprogress nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #6 = { mustprogress nocallback nofree nounwind willreturn memory(argmem: write) }
attributes #7 = { inlinehint mustprogress nofree nosync nounwind willreturn memory(none) 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 #8 = { 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 #9 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #10 = { nounwind }
attributes #11 = { noreturn nounwind }
attributes #12 = { nounwind willreturn memory(read) }
attributes #13 = { nounwind willreturn memory(none) }

!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, !10, i64 16}
!6 = !{!"MDBX_cursor", !7, i64 0, !8, i64 4, !8, i64 6, !8, i64 7, !10, i64 8, !10, i64 16, !10, i64 24, !10, i64 32, !10, i64 40, !8, i64 48, !8, i64 304, !10, i64 368, !10, i64 376}
!7 = !{!"int", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!"any pointer", !8, i64 0}
!11 = !{!12, !10, i64 80}
!12 = !{!"MDBX_txn", !7, i64 0, !7, i64 4, !13, i64 8, !13, i64 16, !10, i64 24, !10, i64 32, !14, i64 40, !13, i64 64, !13, i64 72, !10, i64 80, !10, i64 88, !10, i64 96, !10, i64 104, !10, i64 112, !10, i64 120, !16, i64 128, !10, i64 160, !8, i64 168}
!13 = !{!"long", !8, i64 0}
!14 = !{!"geo", !15, i64 0, !15, i64 2, !7, i64 4, !7, i64 8, !8, i64 12, !8, i64 16}
!15 = !{!"short", !8, i64 0}
!16 = !{!"MDBX_canary", !13, i64 0, !13, i64 8, !13, i64 16, !13, i64 24}
!17 = !{!8, !8, i64 0}
!18 = !{!10, !10, i64 0}
!19 = !{!20, !8, i64 25}
!20 = !{!"libmdbx_globals", !8, i64 0, !7, i64 16, !7, i64 20, !8, i64 24, !8, i64 25, !8, i64 26, !21, i64 27, !7, i64 28, !8, i64 32, !8, i64 40, !13, i64 80, !10, i64 88}
!21 = !{!"_Bool", !8, i64 0}
!22 = !{!"branch_weights", !"expected", i32 1, i32 2000}
!23 = !{!15, !15, i64 0}
!24 = !{!"branch_weights", !"expected", i32 2000, i32 1}
!25 = !{!20, !8, i64 26}
!26 = !{!7, !7, i64 0}
!27 = !{!28, !13, i64 8}
!28 = !{!"iovec", !10, i64 0, !13, i64 8}
!29 = !{!6, !10, i64 24}
!30 = !{!31, !15, i64 2}
!31 = !{!"tree", !15, i64 0, !15, i64 2, !7, i64 4, !7, i64 8, !7, i64 12, !7, i64 16, !7, i64 20, !13, i64 24, !13, i64 32, !13, i64 40}
!32 = !{!31, !7, i64 8}
!33 = !{!13, !13, i64 0}
!34 = !{!6, !10, i64 32}
!35 = !{!36, !10, i64 0}
!36 = !{!"clc2", !37, i64 0, !37, i64 24}
!37 = !{!"clc", !10, i64 0, !13, i64 8, !13, i64 16}
!38 = distinct !{!38, !39}
!39 = !{!"llvm.loop.mustprogress"}
!40 = !{!31, !7, i64 4}
!41 = !{!"branch_weights", i32 1, i32 4001}
!42 = !{!"branch_weights", !"expected", i32 -2147483648, i32 0}
!43 = !{i64 0, i64 8, !18, i64 8, i64 8, !33}
!44 = !{!"branch_weights", i32 4000000, i32 4001}
!45 = !{!"branch_weights", i32 2000, i32 4002001}
!46 = !{!28, !10, i64 0}
!47 = distinct !{!47, !39, !48, !49}
!48 = !{!"llvm.loop.isvectorized", i32 1}
!49 = !{!"llvm.loop.unroll.runtime.disable"}
!50 = distinct !{!50, !51}
!51 = !{!"llvm.loop.unroll.disable"}
!52 = distinct !{!52, !39, !48}
!53 = distinct !{!53, !39, !48, !49}
!54 = distinct !{!54, !39, !48}
!55 = distinct !{!55, !39}
!56 = !{!"branch_weights", i32 1073205, i32 2146410443}
!57 = !{!12, !10, i64 120}
!58 = !{!59, !10, i64 368}
!59 = !{!"cursor_couple", !6, i64 0, !10, i64 384, !60, i64 392}
!60 = !{!"inner_cursor", !6, i64 0, !31, i64 384}
!61 = distinct !{!61, !39, !48, !49}
!62 = distinct !{!62, !39, !48}
!63 = !{!"branch_weights", i32 1, i32 4000, i32 1}
!64 = !{!"branch_weights", !"expected", i32 271110, i32 2147212538}
!65 = !{!"branch_weights", i32 4002001, i32 2000}
!66 = distinct !{!66, !39, !48, !49}
!67 = distinct !{!67, !51}
!68 = distinct !{!68, !39, !48}
!69 = distinct !{!69, !39}
!70 = distinct !{!70, !39}
!71 = distinct !{!71, !51}
!72 = distinct !{!72, !39, !48, !49}
!73 = !{!74, !7, i64 8}
!74 = !{!"MDBX_env", !8, i64 0, !7, i64 4, !7, i64 8, !75, i64 16, !7, i64 56, !7, i64 60, !75, i64 64, !10, i64 104, !15, i64 112, !15, i64 114, !15, i64 116, !15, i64 118, !15, i64 120, !15, i64 122, !8, i64 124, !8, i64 128, !8, i64 129, !15, i64 130, !7, i64 132, !7, i64 136, !7, i64 140, !7, i64 144, !76, i64 152, !10, i64 184, !10, i64 192, !10, i64 200, !10, i64 208, !10, i64 216, !7, i64 224, !7, i64 228, !7, i64 232, !10, i64 240, !10, i64 248, !13, i64 256, !77, i64 264, !79, i64 320, !21, i64 360, !10, i64 368, !10, i64 376, !10, i64 384, !80, i64 392, !8, i64 400, !7, i64 440, !7, i64 444, !10, i64 448, !81, i64 456, !8, i64 496, !8, i64 536}
!75 = !{!"osal_mmap", !8, i64 0, !7, i64 8, !13, i64 16, !13, i64 24, !13, i64 32}
!76 = !{!"", !10, i64 0, !10, i64 8, !10, i64 16, !10, i64 24}
!77 = !{!"", !7, i64 0, !7, i64 4, !7, i64 8, !7, i64 12, !13, i64 16, !8, i64 24, !8, i64 25, !8, i64 26, !8, i64 27, !7, i64 28, !7, i64 32, !21, i64 36, !21, i64 37, !21, i64 38, !78, i64 40, !8, i64 48}
!78 = !{!"", !15, i64 0, !15, i64 2, !15, i64 4, !15, i64 6}
!79 = !{!"", !13, i64 0, !13, i64 8, !13, i64 16, !13, i64 24, !13, i64 32}
!80 = !{!"", !13, i64 0}
!81 = !{!"osal_ioring", !7, i64 0, !7, i64 4, !7, i64 8, !10, i64 16, !10, i64 24, !10, i64 32}
!82 = distinct !{!82, !39, !48}
!83 = distinct !{!83, !39, !48, !49}
!84 = distinct !{!84, !39, !48}
!85 = distinct !{!85, !39, !48, !49}
!86 = distinct !{!86, !39, !48}
!87 = !{!6, !10, i64 40}
!88 = distinct !{!88, !39, !48, !49}
!89 = distinct !{!89, !39, !49, !48}
!90 = distinct !{!90, !39}
!91 = distinct !{!91, !39}
!92 = !{!12, !7, i64 4}
!93 = !{!74, !10, i64 104}


; Effective O3 passes: BDCEPass,ConstraintEliminationPass,CorrelatedValuePropagationPass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferFunctionAttrsPass,InstCombinePass,InstSimplifyPass,JumpThreadingPass,LCSSAPass,LICMPass,LoopLoadEliminationPass,LoopRotatePass,LoopSimplifyPass,LoopUnrollPass,LoopVectorizePass,LowerExpectIntrinsicPass,MergedLoadStoreMotionPass,ReassociatePass,SCCPPass,SLPVectorizerPass,SROAPass,SimplifyCFGPass,TailCallElimPass