test.ll

; ModuleID = 'foo'
source_filename = "foo"

%Runtime = type { %RuntimeData*, %Env*, %Array }
%RuntimeData = type { i64, i64, i8*, i64, i256, i8*, i64, i256, i256, i64 }
%Env = type opaque
%Array = type { i256*, i64, i64 }
%evm.txctx = type { i256, [20 x i8], [20 x i8], i64, i64, i64, i256 }

@code = private unnamed_addr constant [255 x i8] c"`\80`@R4\80\15a\00\10W`\00\80\FD[P`\DF\80a\00\1F`\009`\00\F3\00`\80`@R`\046\10`?W`\005|\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\90\04c\FF\FF\FF\FF\16\80c\16\83\82\B8\14`DW[`\00\80\FD[4\80\15`OW`\00\80\FD[P`|`\04\806\03\81\01\90\80\805`\03\0B\90` \01\90\92\91\90\805`\03\0B\90` \01\90\92\91\90PPP`\98V[`@Q\80\82`\03\0B`\03\0B\81R` \01\91PP`@Q\80\91\03\90\F3[`\00\81`\03\0B\83`\03\0B\81\15\15`\AAW\FE[\05\90P\92\91PPV\00\A1ebzzr0X qe)'\AB\00\DD\CF\93\A6\16\F3\DF\22\F0\905W\CE\D1\D0$.\13\DA\FC\16\F5\E3\A2\E4b\00)\00"

define i32 @foo(%Runtime* %rt) {
Entry:
  %a.0 = alloca i256
  %txctx.loaded = alloca i1
  store i1 false, i1* %txctx.loaded
  %txctx = alloca %evm.txctx
  %0 = getelementptr inbounds %Runtime, %Runtime* %rt, i32 0, i32 0
  %dataPtr = load %RuntimeData*, %RuntimeData** %0
  %mem = getelementptr inbounds %Runtime, %Runtime* %rt, i32 0, i32 2
  %1 = getelementptr inbounds %Runtime, %Runtime* %rt, i32 0, i32 1
  %env = load %Env*, %Env** %1
  %stack.base = call i256* @malloc(i64 32768)
  %stack.size = alloca i64
  store i64 0, i64* %stack.size
  %data = load %RuntimeData, %RuntimeData* %dataPtr
  %msg.gas = extractvalue %RuntimeData %data, 0
  %tx.gasprice = extractvalue %RuntimeData %data, 1
  %msg.data.ptr = extractvalue %RuntimeData %data, 2
  %msg.data.size = extractvalue %RuntimeData %data, 3
  %msg.value = extractvalue %RuntimeData %data, 4
  %code.ptr = extractvalue %RuntimeData %data, 5
  %code.size = extractvalue %RuntimeData %data, 6
  %msg.address = extractvalue %RuntimeData %data, 7
  %msg.sender = extractvalue %RuntimeData %data, 8
  %msg.depth = extractvalue %RuntimeData %data, 9
  %gas.ptr = alloca i64
  store i64 %msg.gas, i64* %gas.ptr
  %returndata.ptr = alloca i8*
  %returndatasize.ptr = alloca i64
  store i64 0, i64* %returndatasize.ptr
  store %Array zeroinitializer, %Array* %mem
  %env.size = alloca i64
  %jmpBuf.words = alloca i8*, i64 3
  %fp = call i8* @llvm.frameaddress(i32 0)
  store i8* %fp, i8** %jmpBuf.words
  %sp = call i8* @llvm.stacksave()
  %jmpBuf.sp = getelementptr inbounds i8*, i8** %jmpBuf.words, i64 2
  store i8* %sp, i8** %jmpBuf.sp
  %jmpBuf = bitcast i8** %jmpBuf.words to i8*
  %2 = call i32 @llvm.eh.sjlj.setjmp(i8* %jmpBuf)
  %3 = icmp eq i32 %2, 0
  br i1 %3, label %.0, label %Abort, !prof !0

.0:                                               ; preds = %Entry
  %sp.0 = call i256* @stack.prepare(i256* %stack.base, i64* %stack.size, i64 0, i64 3, i64 1, i8* %jmpBuf)
  call void @gas.check(i64* %gas.ptr, i64 30, i8* %jmpBuf)
  call void @mem.require(%Array* %mem, i256 64, i256 32, i8* %jmpBuf, i64* %gas.ptr)
  call void @mstore(%Array* %mem, i256 64, i256 128)
  %4 = call i256 @llvm.bswap.i256(i256 %msg.value)
  %iszero = icmp eq i256 %4, 0
  %5 = zext i1 %iszero to i256
  %jump.check = icmp ne i256 %5, 0
  %6 = getelementptr i256, i256* %sp.0, i64 0
  store i256 %4, i256* %6, align 16
  br i1 %jump.check, label %.16, label %.12, !destIdx !1

.12:                                              ; preds = %.0
  %sp.12 = call i256* @stack.prepare(i256* %stack.base, i64* %stack.size, i64 0, i64 2, i64 2, i8* %jmpBuf)
  call void @gas.check(i64* %gas.ptr, i64 6, i8* %jmpBuf)
  %7 = getelementptr i256, i256* %sp.12, i64 0
  store i256 0, i256* %7, align 16
  %8 = getelementptr i256, i256* %sp.12, i64 1
  store i256 0, i256* %8, align 16
  br label %Exit

.16:                                              ; preds = %.0, %JumpTable
  %sp.16 = call i256* @stack.prepare(i256* %stack.base, i64* %stack.size, i64 -1, i64 3, i64 -1, i8* %jmpBuf)
  call void @gas.check(i64* %gas.ptr, i64 21, i8* %jmpBuf)
  %9 = getelementptr i256, i256* %sp.16, i64 -1
  %10 = load i256, i256* %9, align 16
  call void @mem.require(%Array* %mem, i256 0, i256 223, i8* %jmpBuf, i64* %gas.ptr)
  call void @gas.check(i64* %gas.ptr, i64 21, i8* %jmpBuf)
  %11 = call i256* @array.getPtr(%Array* %mem, i64 0)
  %12 = call i256* @array.getPtr(%Array* %mem, i64 223)
  %13 = bitcast i256* %11 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %13, i8* getelementptr inbounds ([255 x i8], [255 x i8]* @code, i32 0, i64 31), i64 223, i32 0, i1 false)
  %14 = bitcast i256* %12 to i8*
  call void @llvm.memset.p0i8.i64(i8* %14, i8 0, i64 0, i32 0, i1 false)
  call void @mem.require(%Array* %mem, i256 0, i256 223, i8* %jmpBuf, i64* %gas.ptr)
  %15 = bitcast %Array* %mem to i8**
  %memory = load i8*, i8** %15
  %16 = getelementptr i8, i8* %memory, i256 0
  %17 = getelementptr inbounds %RuntimeData, %RuntimeData* %dataPtr, i32 0, i32 2
  store i8* %16, i8** %17
  %18 = getelementptr inbounds %RuntimeData, %RuntimeData* %dataPtr, i32 0, i32 3
  store i64 223, i64* %18
  br label %Exit

.94:                                              ; preds = %JumpTable
  %sp.94 = call i256* @stack.prepare(i256* %stack.base, i64* %stack.size, i64 0, i64 2, i64 2, i8* %jmpBuf)
  call void @gas.check(i64* %gas.ptr, i64 7, i8* %jmpBuf)
  %19 = getelementptr i256, i256* %sp.94, i64 0
  store i256 0, i256* %19, align 16
  %20 = getelementptr i256, i256* %sp.94, i64 1
  store i256 0, i256* %20, align 16
  br label %Exit

.99:                                              ; preds = %JumpTable
  %sp.99 = call i256* @stack.prepare(i256* %stack.base, i64* %stack.size, i64 0, i64 3, i64 1, i8* %jmpBuf)
  call void @gas.check(i64* %gas.ptr, i64 22, i8* %jmpBuf)
  %21 = call i256 @llvm.bswap.i256(i256 %msg.value)
  %iszero1 = icmp eq i256 %21, 0
  %22 = zext i1 %iszero1 to i256
  %jump.check2 = icmp ne i256 %22, 0
  %23 = getelementptr i256, i256* %sp.99, i64 0
  store i256 %21, i256* %23, align 16
  br i1 %jump.check2, label %Abort, label %.106, !destIdx !2

.106:                                             ; preds = %.99
  %sp.106 = call i256* @stack.prepare(i256* %stack.base, i64* %stack.size, i64 0, i64 2, i64 2, i8* %jmpBuf)
  call void @gas.check(i64* %gas.ptr, i64 6, i8* %jmpBuf)
  %24 = getelementptr i256, i256* %sp.106, i64 0
  store i256 0, i256* %24, align 16
  %25 = getelementptr i256, i256* %sp.106, i64 1
  store i256 0, i256* %25, align 16
  br label %Exit

.110:                                             ; preds = %JumpTable
  %sp.110 = call i256* @stack.prepare(i256* %stack.base, i64* %stack.size, i64 -1, i64 6, i64 2, i8* %jmpBuf)
  call void @gas.check(i64* %gas.ptr, i64 116, i8* %jmpBuf)
  %26 = getelementptr i256, i256* %sp.110, i64 -1
  %27 = load i256, i256* %26, align 16
  %28 = zext i64 %msg.data.size to i256
  %29 = sub i256 %28, 4
  %30 = add i256 4, %29
  %31 = bitcast i256* %a.0 to i8*
  %32 = zext i64 %msg.data.size to i256
  %33 = trunc i256 %32 to i64
  %34 = icmp ult i256 4, %32
  %35 = select i1 %34, i256 4, i256 %32
  %idx = trunc i256 %35 to i64
  %36 = add nuw i64 %idx, 32
  %37 = icmp ule i64 %36, %33
  %38 = select i1 %37, i64 %36, i64 %33
  %39 = sub nuw i64 %38, %idx
  %40 = sub nuw i64 32, %39
  %41 = getelementptr i8, i8* %msg.data.ptr, i64 %idx
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %31, i8* %41, i64 %39, i32 1, i1 false)
  %42 = getelementptr i8, i8* %31, i64 %39
  call void @llvm.memset.p0i8.i64(i8* %42, i8 0, i64 %40, i32 1, i1 false)
  %43 = load i256, i256* %a.0
  %44 = call i256 @llvm.bswap.i256(i256 %43)
  %bitval = lshr i256 %44, 31
  %bittest = trunc i256 %bitval to i1
  %45 = or i256 %44, -2147483648
  %46 = and i256 %44, 2147483647
  %47 = select i1 %bittest, i256 %45, i256 %46
  %48 = select i1 true, i256 %47, i256 %44
  %49 = bitcast i256* %a.0 to i8*
  %50 = zext i64 %msg.data.size to i256
  %51 = trunc i256 %50 to i64
  %52 = icmp ult i256 36, %50
  %53 = select i1 %52, i256 36, i256 %50
  %idx3 = trunc i256 %53 to i64
  %54 = add nuw i64 %idx3, 32
  %55 = icmp ule i64 %54, %51
  %56 = select i1 %55, i64 %54, i64 %51
  %57 = sub nuw i64 %56, %idx3
  %58 = sub nuw i64 32, %57
  %59 = getelementptr i8, i8* %msg.data.ptr, i64 %idx3
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %49, i8* %59, i64 %57, i32 1, i1 false)
  %60 = getelementptr i8, i8* %49, i64 %57
  call void @llvm.memset.p0i8.i64(i8* %60, i8 0, i64 %58, i32 1, i1 false)
  %61 = load i256, i256* %a.0
  %62 = call i256 @llvm.bswap.i256(i256 %61)
  %bitval4 = lshr i256 %62, 31
  %bittest5 = trunc i256 %bitval4 to i1
  %63 = or i256 %62, -2147483648
  %64 = and i256 %62, 2147483647
  %65 = select i1 %bittest5, i256 %63, i256 %64
  %66 = select i1 true, i256 %65, i256 %62
  %67 = getelementptr i256, i256* %sp.110, i64 -1
  store i256 124, i256* %67, align 16
  %68 = getelementptr i256, i256* %sp.110, i64 0
  store i256 %48, i256* %68, align 16
  %69 = getelementptr i256, i256* %sp.110, i64 1
  store i256 %66, i256* %69, align 16
  br label %Abort, !destIdx !3

.155:                                             ; preds = %JumpTable
  %sp.155 = call i256* @stack.prepare(i256* %stack.base, i64* %stack.size, i64 -1, i64 4, i64 -1, i8* %jmpBuf)
  call void @gas.check(i64* %gas.ptr, i64 66, i8* %jmpBuf)
  call void @mem.require(%Array* %mem, i256 64, i256 32, i8* %jmpBuf, i64* %gas.ptr)
  %70 = call i256 @mload(%Array* %mem, i256 64)
  %71 = getelementptr i256, i256* %sp.155, i64 -1
  %72 = load i256, i256* %71, align 16
  %bitval6 = lshr i256 %72, 31
  %bittest7 = trunc i256 %bitval6 to i1
  %73 = or i256 %72, -2147483648
  %74 = and i256 %72, 2147483647
  %75 = select i1 %bittest7, i256 %73, i256 %74
  %76 = select i1 true, i256 %75, i256 %72
  %bitval8 = lshr i256 %76, 31
  %bittest9 = trunc i256 %bitval8 to i1
  %77 = or i256 %76, -2147483648
  %78 = and i256 %76, 2147483647
  %79 = select i1 %bittest9, i256 %77, i256 %78
  %80 = select i1 true, i256 %79, i256 %76
  call void @mem.require(%Array* %mem, i256 %70, i256 32, i8* %jmpBuf, i64* %gas.ptr)
  call void @mstore(%Array* %mem, i256 %70, i256 %80)
  %81 = add i256 32, %70
  call void @mem.require(%Array* %mem, i256 64, i256 32, i8* %jmpBuf, i64* %gas.ptr)
  %82 = call i256 @mload(%Array* %mem, i256 64)
  %83 = sub i256 %81, %82
  call void @mem.require(%Array* %mem, i256 %82, i256 %83, i8* %jmpBuf, i64* %gas.ptr)
  %84 = bitcast %Array* %mem to i8**
  %memory10 = load i8*, i8** %84
  %85 = getelementptr i8, i8* %memory10, i256 %82
  %86 = getelementptr inbounds %RuntimeData, %RuntimeData* %dataPtr, i32 0, i32 2
  store i8* %85, i8** %86
  %87 = trunc i256 %83 to i64
  %88 = getelementptr inbounds %RuntimeData, %RuntimeData* %dataPtr, i32 0, i32 3
  store i64 %87, i64* %88
  br label %Exit

.183:                                             ; preds = %JumpTable
  %sp.183 = call i256* @stack.prepare(i256* %stack.base, i64* %stack.size, i64 -2, i64 5, i64 3, i8* %jmpBuf)
  call void @gas.check(i64* %gas.ptr, i64 48, i8* %jmpBuf)
  %89 = getelementptr i256, i256* %sp.183, i64 -1
  %90 = load i256, i256* %89, align 16
  %bitval11 = lshr i256 %90, 31
  %bittest12 = trunc i256 %bitval11 to i1
  %91 = or i256 %90, -2147483648
  %92 = and i256 %90, 2147483647
  %93 = select i1 %bittest12, i256 %91, i256 %92
  %94 = select i1 true, i256 %93, i256 %90
  %95 = getelementptr i256, i256* %sp.183, i64 -2
  %96 = load i256, i256* %95, align 16
  %bitval13 = lshr i256 %96, 31
  %bittest14 = trunc i256 %bitval13 to i1
  %97 = or i256 %96, -2147483648
  %98 = and i256 %96, 2147483647
  %99 = select i1 %bittest14, i256 %97, i256 %98
  %100 = select i1 true, i256 %99, i256 %96
  %iszero15 = icmp eq i256 %94, 0
  %101 = zext i1 %iszero15 to i256
  %iszero16 = icmp eq i256 %101, 0
  %102 = zext i1 %iszero16 to i256
  %jump.check17 = icmp ne i256 %102, 0
  %103 = getelementptr i256, i256* %sp.183, i64 -2
  store i256 %96, i256* %103, align 16
  %104 = getelementptr i256, i256* %sp.183, i64 -1
  store i256 %90, i256* %104, align 16
  %105 = getelementptr i256, i256* %sp.183, i64 0
  store i256 0, i256* %105, align 16
  %106 = getelementptr i256, i256* %sp.183, i64 1
  store i256 %94, i256* %106, align 16
  %107 = getelementptr i256, i256* %sp.183, i64 2
  store i256 %100, i256* %107, align 16
  br i1 %jump.check17, label %Abort, label %.200, !destIdx !4

.200:                                             ; preds = %.183
  %sp.200 = call i256* @stack.prepare(i256* %stack.base, i64* %stack.size, i64 0, i64 0, i64 0, i8* %jmpBuf)
  br label %Exit

.201:                                             ; preds = %JumpTable
  %sp.201 = call i256* @stack.prepare(i256* %stack.base, i64* %stack.size, i64 -6, i64 0, i64 -5, i8* %jmpBuf)
  call void @gas.check(i64* %gas.ptr, i64 29, i8* %jmpBuf)
  %108 = getelementptr i256, i256* %sp.201, i64 -1
  %109 = load i256, i256* %108, align 16
  %110 = getelementptr i256, i256* %sp.201, i64 -2
  %111 = load i256, i256* %110, align 16
  %112 = icmp eq i256 %111, 0
  %113 = icmp eq i256 %111, -1
  %114 = select i1 %112, i256 1, i256 %111
  %115 = sdiv i256 %109, %114
  %116 = select i1 %112, i256 0, i256 %115
  %117 = sub i256 0, %109
  %118 = select i1 %113, i256 %117, i256 %116
  %119 = getelementptr i256, i256* %sp.201, i64 -3
  %120 = load i256, i256* %119, align 16
  %121 = getelementptr i256, i256* %sp.201, i64 -6
  %122 = load i256, i256* %121, align 16
  %123 = getelementptr i256, i256* %sp.201, i64 -5
  %124 = load i256, i256* %123, align 16
  %125 = getelementptr i256, i256* %sp.201, i64 -4
  %126 = load i256, i256* %125, align 16
  %127 = getelementptr i256, i256* %sp.201, i64 -6
  store i256 %118, i256* %127, align 16
  br label %JumpTable, !destIdx !5

Stop:                                             ; No predecessors!
  br label %Exit

JumpTable:                                        ; preds = %.201
  switch i256 %122, label %Abort [
    i256 16, label %.16
    i256 94, label %.94
    i256 99, label %.99
    i256 110, label %.110
    i256 155, label %.155
    i256 183, label %.183
    i256 201, label %.201
  ]

Abort:                                            ; preds = %.183, %.110, %.99, %Entry, %JumpTable
  br label %Exit

Exit:                                             ; preds = %Abort, %Stop, %.200, %.155, %.106, %.94, %.16, %.12
  %ret = phi i32 [ -1, %.12 ], [ 1, %.16 ], [ -1, %.94 ], [ -1, %.106 ], [ 1, %.155 ], [ -1, %.200 ], [ 0, %Stop ], [ -1, %Abort ]
  call void @free(i256* %stack.base)
  %msg.gas.ptr = getelementptr inbounds %RuntimeData, %RuntimeData* %dataPtr, i32 0, i32 0
  %gas = load i64, i64* %gas.ptr
  store i64 %gas, i64* %msg.gas.ptr
  ret i32 %ret
}

declare void @evm.get_tx_context(%evm.txctx*, %Env*)

define private fastcc void @loadTxCtx(i1* %flag, %evm.txctx* %txctx, %Env* %env) {
Check:
  %0 = load i1, i1* %flag
  br i1 %0, label %Exit, label %Load

Load:                                             ; preds = %Check
  store i1 true, i1* %flag
  call void @evm.get_tx_context(%evm.txctx* %txctx, %Env* %env)
  br label %Exit

Exit:                                             ; preds = %Load, %Check
  ret void
}

; Function Attrs: nounwind
declare noalias i256* @malloc(i64) #0

; Function Attrs: nounwind
declare void @free(i256* nocapture) #0

; Function Attrs: nounwind
define private void @gas.check(i64* nocapture %gasPtr, i64 %cost, i8* %jmpBuf) #0 {
Check:
  %gas = load i64, i64* %gasPtr
  %gasUpdated = sub nsw i64 %gas, %cost
  %gasOk = icmp sge i64 %gasUpdated, 0
  br i1 %gasOk, label %Update, label %OutOfGas, !prof !0

Update:                                           ; preds = %Check
  store i64 %gasUpdated, i64* %gasPtr
  ret void

OutOfGas:                                         ; preds = %Check
  call void @llvm.eh.sjlj.longjmp(i8* %jmpBuf)
  unreachable
}

; Function Attrs: noreturn nounwind
declare void @llvm.eh.sjlj.longjmp(i8*) #1

; Function Attrs: nounwind readnone
declare i8* @llvm.frameaddress(i32) #2

; Function Attrs: nounwind
declare i8* @llvm.stacksave() #0

; Function Attrs: nounwind
declare i32 @llvm.eh.sjlj.setjmp(i8*) #0

; Function Attrs: nounwind
define private i256* @stack.prepare(i256* readnone %base, i64* noalias nocapture %size.ptr, i64 %min, i64 %max, i64 %diff, i8* %jmpBuf) #0 {
Check:
  %size = load i64, i64* %size.ptr, align 4
  %size.min = add nsw i64 %size, %min
  %size.max = add nuw nsw i64 %size, %max
  %ok.min = icmp sge i64 %size.min, 0
  %ok.max = icmp ule i64 %size.max, 1024
  %ok = and i1 %ok.min, %ok.max
  br i1 %ok, label %Update, label %OutOfStack, !prof !0

Update:                                           ; preds = %Check
  %size.next = add nsw i64 %size, %diff
  store i64 %size.next, i64* %size.ptr, align 4
  %sp = getelementptr i256, i256* %base, i64 %size
  ret i256* %sp

OutOfStack:                                       ; preds = %Check
  call void @llvm.eh.sjlj.longjmp(i8* %jmpBuf)
  unreachable
}

; Function Attrs: nounwind
define private void @mem.require(%Array* %mem, i256 %blkOffset, i256 %blkSize, i8* %jmpBuf, i64* %gas) #0 {
Pre:
  %0 = icmp ne i256 %blkSize, 0
  br i1 %0, label %Check, label %Return, !prof !0

Check:                                            ; preds = %Pre
  %blkOffsetOk = icmp ule i256 %blkOffset, 8589934592
  %1 = trunc i256 %blkOffset to i64
  %bklO = select i1 %blkOffsetOk, i64 %1, i64 8589934592
  %blkSizeOk = icmp ule i256 %blkSize, 8589934592
  %2 = trunc i256 %blkSize to i64
  %bklS = select i1 %blkSizeOk, i64 %2, i64 8589934592
  %sizeReq0 = add nuw i64 %bklO, %bklS
  %3 = add nuw i64 %sizeReq0, 31
  %sizeReq = and i64 %3, -32
  %sizePtr = getelementptr inbounds %Array, %Array* %mem, i32 0, i32 1
  %array.size = load i64, i64* %sizePtr
  %sizeOk = icmp ule i64 %sizeReq, %array.size
  br i1 %sizeOk, label %Return, label %Resize, !prof !0

Resize:                                           ; preds = %Check
  %4 = lshr i64 %sizeReq, 5
  %5 = mul nuw i64 %4, %4
  %6 = lshr i64 %5, 9
  %7 = mul nuw i64 %4, 3
  %8 = add i64 %7, %6
  %9 = lshr i64 %array.size, 5
  %10 = mul nuw i64 %9, %9
  %11 = lshr i64 %10, 9
  %12 = mul nuw i64 %9, 3
  %13 = add i64 %12, %11
  %14 = sub nuw i64 %8, %13
  %costOk = and i1 %blkOffsetOk, %blkSizeOk
  %c = select i1 %costOk, i64 %14, i64 9223372036854775807
  call void @gas.check(i64* %gas, i64 %c, i8* %jmpBuf)
  call void @array.extend(%Array* %mem, i64 %sizeReq)
  br label %Return

Return:                                           ; preds = %Resize, %Check, %Pre
  ret void
}

; Function Attrs: nounwind
define private void @array.extend(%Array* nocapture %arrayPtr, i64 %newSize) #0 {
  %dataPtr = bitcast %Array* %arrayPtr to i8**
  %sizePtr = getelementptr inbounds %Array, %Array* %arrayPtr, i32 0, i32 1
  %capPtr = getelementptr inbounds %Array, %Array* %arrayPtr, i32 0, i32 2
  %data = load i8*, i8** %dataPtr
  %size = load i64, i64* %sizePtr
  %extSize = sub nuw i64 %newSize, %size
  %newData = call i8* @realloc(i8* %data, i64 %newSize)
  %extPtr = getelementptr i8, i8* %newData, i64 %size
  call void @llvm.memset.p0i8.i64(i8* %extPtr, i8 0, i64 %extSize, i32 16, i1 false)
  store i8* %newData, i8** %dataPtr
  store i64 %newSize, i64* %sizePtr
  store i64 %newSize, i64* %capPtr
  ret void
}

; Function Attrs: nounwind
declare noalias i8* @realloc(i8* nocapture, i64) #0

; Function Attrs: argmemonly nounwind
declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i32, i1) #3

define private void @mstore(%Array* %mem, i256 %index, i256 %value) {
  %1 = call i256 @llvm.bswap.i256(i256 %value)
  %2 = trunc i256 %index to i64
  %3 = call i256* @array.getPtr(%Array* %mem, i64 %2)
  store i256 %1, i256* %3
  ret void
}

; Function Attrs: nounwind readnone speculatable
declare i256 @llvm.bswap.i256(i256) #4

; Function Attrs: nounwind
define private i256* @array.getPtr(%Array* nocapture %arrayPtr, i64 %index) #0 {
  %dataPtr = bitcast %Array* %arrayPtr to i8**
  %data = load i8*, i8** %dataPtr
  %bytePtr = getelementptr i8, i8* %data, i64 %index
  %wordPtr = bitcast i8* %bytePtr to i256*
  ret i256* %wordPtr
}

; Function Attrs: argmemonly nounwind
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32, i1) #3

define private i256 @mload(%Array* %mem, i256 %index) {
  %1 = trunc i256 %index to i64
  %2 = call i256* @array.getPtr(%Array* %mem, i64 %1)
  %3 = load i256, i256* %2
  %4 = call i256 @llvm.bswap.i256(i256 %3)
  ret i256 %4
}

attributes #0 = { nounwind }
attributes #1 = { noreturn nounwind }
attributes #2 = { nounwind readnone }
attributes #3 = { argmemonly nounwind }
attributes #4 = { nounwind readnone speculatable }

!0 = !{!"branch_weights", i32 1, i32 0}
!1 = !{i256 16}
!2 = !{i256 79}
!3 = !{i256 152}
!4 = !{i256 170}
!5 = !{i256 %122}