bug-with-D144086.ll

llvm.func @pack_pad_transpose_1x9xi8_into_2x4x8x4xi8_dispatch_0(%arg0: !llvm.ptr<struct<"iree_hal_executable_environment_v0_t", (ptr<i32>, ptr<func<i32 (ptr<func<i32 (ptr<i8>, ptr<i8>, ptr<i8>)>>, ptr<i8>, ptr<i8>, ptr<i8>)>>, ptr<ptr<func<i32 (ptr<i8>, ptr<i8>, ptr<i8>)>>>, ptr<ptr<i8>>, struct<"iree_hal_processor_v0_t", (array<8 x i64>)>)>> {llvm.align = 16 : i64, llvm.noalias}, %arg1: !llvm.ptr<struct<"iree_hal_executable_dispatch_state_v0_t", (i32, i32, i16, i16, i32, i32, i16, i8, i8, ptr<i32>, ptr<ptr<i8>>, ptr<i64>)>> {llvm.align = 16 : i64, llvm.noalias}, %arg2: !llvm.ptr<struct<"iree_hal_executable_workgroup_state_v0_t", (i32, i32, i16, i16, i32, ptr<ptr<i8>>, i32)>> {llvm.align = 16 : i64, llvm.noalias}) -> i32 {
  %0 = llvm.mlir.constant(0 : i32) : i32
  %1 = llvm.mlir.constant(7 : i64) : i64
  %2 = llvm.mlir.constant(6 : i64) : i64
  %3 = llvm.mlir.constant(5 : i64) : i64
  %4 = llvm.mlir.constant(4 : i64) : i64
  %5 = llvm.mlir.constant(3 : i64) : i64
  %6 = llvm.mlir.constant(2 : i64) : i64
  %7 = llvm.mlir.constant(36 : index) : i64
  %8 = llvm.mlir.constant(-8 : index) : i64
  %9 = llvm.mlir.constant(-4 : index) : i64
  %10 = llvm.mlir.constant(16 : index) : i64
  %11 = llvm.mlir.constant(128 : index) : i64
  %12 = llvm.mlir.constant(1 : i64) : i64
  %13 = llvm.mlir.constant(63 : index) : i64
  %14 = llvm.mlir.constant(9 : index) : i64
  %15 = llvm.mlir.constant(0 : i64) : i64
  %16 = llvm.mlir.constant(3 : index) : i64
  %17 = llvm.mlir.constant(5 : index) : i64
  %18 = llvm.mlir.constant(6 : index) : i64
  %19 = llvm.mlir.constant(7 : index) : i64
  %20 = llvm.mlir.constant(dense<0> : vector<8x4xi8>) : !llvm.array<8 x vector<4xi8>>
  %21 = llvm.mlir.constant(0 : i8) : i8
  %22 = llvm.mlir.constant(0 : index) : i64
  %23 = llvm.mlir.constant(2 : index) : i64
  %24 = llvm.mlir.constant(4 : index) : i64
  %25 = llvm.mlir.constant(1 : index) : i64
  %26 = llvm.mlir.constant(8 : index) : i64
  %27 = llvm.mlir.constant(32 : index) : i64
  %28 = llvm.mlir.null : !llvm.ptr<i8>
  %29 = llvm.getelementptr %28[32] : (!llvm.ptr<i8>) -> !llvm.ptr<i8>
  %30 = llvm.ptrtoint %29 : !llvm.ptr<i8> to i64
  %31 = llvm.alloca %30 x i8 {alignment = 32 : i64} : (i64) -> !llvm.ptr<i8>
  %32 = llvm.mlir.undef : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<2 x i64>, array<2 x i64>)>
  %33 = llvm.insertvalue %31, %32[0] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<2 x i64>, array<2 x i64>)> 
  %34 = llvm.insertvalue %31, %33[1] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<2 x i64>, array<2 x i64>)> 
  %35 = llvm.insertvalue %22, %34[2] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<2 x i64>, array<2 x i64>)> 
  %36 = llvm.insertvalue %24, %35[3, 0] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<2 x i64>, array<2 x i64>)> 
  %37 = llvm.insertvalue %26, %36[3, 1] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<2 x i64>, array<2 x i64>)> 
  %38 = llvm.insertvalue %26, %37[4, 0] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<2 x i64>, array<2 x i64>)> 
  %39 = llvm.insertvalue %25, %38[4, 1] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<2 x i64>, array<2 x i64>)> 
  %40 = llvm.load %arg1 : !llvm.ptr<struct<"iree_hal_executable_dispatch_state_v0_t", (i32, i32, i16, i16, i32, i32, i16, i8, i8, ptr<i32>, ptr<ptr<i8>>, ptr<i64>)>>
  %41 = llvm.extractvalue %40[10] : !llvm.struct<"iree_hal_executable_dispatch_state_v0_t", (i32, i32, i16, i16, i32, i32, i16, i8, i8, ptr<i32>, ptr<ptr<i8>>, ptr<i64>)> 
  %42 = llvm.load %41 : !llvm.ptr<ptr<i8>>
  %43 = llvm.ptrtoint %42 : !llvm.ptr<i8> to i64
  %44 = llvm.and %43, %13  : i64
  %45 = llvm.icmp "eq" %44, %22 : i64
  "llvm.intr.assume"(%45) : (i1) -> ()
  %46 = llvm.load %arg1 : !llvm.ptr<struct<"iree_hal_executable_dispatch_state_v0_t", (i32, i32, i16, i16, i32, i32, i16, i8, i8, ptr<i32>, ptr<ptr<i8>>, ptr<i64>)>>
  %47 = llvm.extractvalue %46[10] : !llvm.struct<"iree_hal_executable_dispatch_state_v0_t", (i32, i32, i16, i16, i32, i32, i16, i8, i8, ptr<i32>, ptr<ptr<i8>>, ptr<i64>)> 
  %48 = llvm.getelementptr %47[1] : (!llvm.ptr<ptr<i8>>) -> !llvm.ptr<ptr<i8>>
  %49 = llvm.load %48 : !llvm.ptr<ptr<i8>>
  %50 = llvm.ptrtoint %49 : !llvm.ptr<i8> to i64
  %51 = llvm.and %50, %13  : i64
  %52 = llvm.icmp "eq" %51, %22 : i64
  "llvm.intr.assume"(%52) : (i1) -> ()
  %53 = llvm.load %arg2 : !llvm.ptr<struct<"iree_hal_executable_workgroup_state_v0_t", (i32, i32, i16, i16, i32, ptr<ptr<i8>>, i32)>>
  %54 = llvm.extractvalue %53[0] : !llvm.struct<"iree_hal_executable_workgroup_state_v0_t", (i32, i32, i16, i16, i32, ptr<ptr<i8>>, i32)> 
  %55 = llvm.zext %54 : i32 to i64
  %56 = llvm.load %arg1 : !llvm.ptr<struct<"iree_hal_executable_dispatch_state_v0_t", (i32, i32, i16, i16, i32, i32, i16, i8, i8, ptr<i32>, ptr<ptr<i8>>, ptr<i64>)>>
  %57 = llvm.extractvalue %56[4] : !llvm.struct<"iree_hal_executable_dispatch_state_v0_t", (i32, i32, i16, i16, i32, i32, i16, i8, i8, ptr<i32>, ptr<ptr<i8>>, ptr<i64>)> 
  %58 = llvm.zext %57 : i32 to i64
  %59 = llvm.extractvalue %53[1] : !llvm.struct<"iree_hal_executable_workgroup_state_v0_t", (i32, i32, i16, i16, i32, ptr<ptr<i8>>, i32)> 
  %60 = llvm.zext %59 : i32 to i64
  %61 = llvm.extractvalue %56[5] : !llvm.struct<"iree_hal_executable_dispatch_state_v0_t", (i32, i32, i16, i16, i32, i32, i16, i8, i8, ptr<i32>, ptr<ptr<i8>>, ptr<i64>)> 
  %62 = llvm.zext %61 : i32 to i64
  %63 = llvm.mul %60, %10  : i64
  %64 = llvm.mul %62, %10  : i64
  llvm.br ^bb1(%63 : i64)
^bb1(%65: i64):  // 2 preds: ^bb0, ^bb20
  %66 = llvm.icmp "slt" %65, %23 : i64
  llvm.cond_br %66, ^bb2, ^bb21
^bb2:  // pred: ^bb1
  %67 = llvm.mul %55, %26  : i64
  %68 = llvm.mul %58, %26  : i64
  llvm.br ^bb3(%67 : i64)
^bb3(%69: i64):  // 2 preds: ^bb2, ^bb19
  %70 = llvm.icmp "slt" %69, %24 : i64
  llvm.cond_br %70, ^bb4(%22 : i64), ^bb20
^bb4(%71: i64):  // 2 preds: ^bb3, ^bb18
  %72 = llvm.icmp "slt" %71, %23 : i64
  llvm.cond_br %72, ^bb5(%22 : i64), ^bb19
^bb5(%73: i64):  // 2 preds: ^bb4, ^bb17
  %74 = llvm.icmp "slt" %73, %24 : i64
  llvm.cond_br %74, ^bb6, ^bb18
^bb6:  // pred: ^bb5
  %75 = llvm.mul %73, %9  : i64
  %76 = llvm.add %75, %25  : i64
  %77 = llvm.icmp "slt" %76, %24 : i64
  %78 = llvm.select %77, %76, %24 : i1, i64
  %79 = llvm.mul %71, %8  : i64
  %80 = llvm.add %79, %14  : i64
  %81 = llvm.icmp "slt" %80, %26 : i64
  %82 = llvm.select %81, %80, %26 : i1, i64
  %83 = llvm.mul %73, %7  : i64
  %84 = llvm.mul %71, %26  : i64
  %85 = llvm.add %83, %84  : i64
  %86 = llvm.insertvalue %42, %32[0] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<2 x i64>, array<2 x i64>)> 
  %87 = llvm.insertvalue %42, %86[1] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<2 x i64>, array<2 x i64>)> 
  %88 = llvm.insertvalue %85, %87[2] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<2 x i64>, array<2 x i64>)> 
  %89 = llvm.insertvalue %78, %88[3, 0] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<2 x i64>, array<2 x i64>)> 
  %90 = llvm.insertvalue %14, %89[4, 0] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<2 x i64>, array<2 x i64>)> 
  %91 = llvm.insertvalue %82, %90[3, 1] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<2 x i64>, array<2 x i64>)> 
  %92 = llvm.insertvalue %25, %91[4, 1] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<2 x i64>, array<2 x i64>)> 
  %93 = llvm.mul %71, %11  : i64
  %94 = llvm.mul %73, %27  : i64
  %95 = llvm.add %93, %94  : i64
  %96 = llvm.icmp "sge" %78, %24 : i64
  %97 = llvm.icmp "sge" %82, %26 : i64
  %98 = llvm.and %96, %97  : i1
  llvm.cond_br %98, ^bb7(%92 : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<2 x i64>, array<2 x i64>)>), ^bb8(%22 : i64)
^bb7(%99: !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<2 x i64>, array<2 x i64>)>):  // 2 preds: ^bb6, ^bb13
  llvm.br ^bb17
^bb8(%100: i64):  // 2 preds: ^bb6, ^bb11
  %101 = llvm.icmp "slt" %100, %24 : i64
  llvm.cond_br %101, ^bb9(%22 : i64), ^bb12
^bb9(%102: i64):  // 2 preds: ^bb8, ^bb10
  %103 = llvm.icmp "slt" %102, %26 : i64
  llvm.cond_br %103, ^bb10, ^bb11
^bb10:  // pred: ^bb9
  %104 = llvm.mul %100, %26  : i64
  %105 = llvm.add %104, %102  : i64
  %106 = llvm.getelementptr %31[%105] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8>
  llvm.store %21, %106 : !llvm.ptr<i8>
  %107 = llvm.add %102, %25  : i64
  llvm.br ^bb9(%107 : i64)
^bb11:  // pred: ^bb9
  %108 = llvm.add %100, %25  : i64
  llvm.br ^bb8(%108 : i64)
^bb12:  // pred: ^bb8
  llvm.br ^bb13(%22 : i64)
^bb13(%109: i64):  // 2 preds: ^bb12, ^bb16
  %110 = llvm.icmp "slt" %109, %78 : i64
  llvm.cond_br %110, ^bb14(%22 : i64), ^bb7(%39 : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<2 x i64>, array<2 x i64>)>)
^bb14(%111: i64):  // 2 preds: ^bb13, ^bb15
  %112 = llvm.icmp "slt" %111, %82 : i64
  llvm.cond_br %112, ^bb15, ^bb16
^bb15:  // pred: ^bb14
  %113 = llvm.mul %109, %14  : i64
  %114 = llvm.add %85, %113  : i64
  %115 = llvm.add %114, %111  : i64
  %116 = llvm.getelementptr %42[%115] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8>
  %117 = llvm.load %116 : !llvm.ptr<i8>
  %118 = llvm.mul %109, %26  : i64
  %119 = llvm.add %118, %111  : i64
  %120 = llvm.getelementptr %31[%119] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8>
  llvm.store %117, %120 : !llvm.ptr<i8>
  %121 = llvm.add %111, %25  : i64
  llvm.br ^bb14(%121 : i64)
^bb16:  // pred: ^bb14
  %122 = llvm.add %109, %25  : i64
  llvm.br ^bb13(%122 : i64)
^bb17:  // pred: ^bb7
  %123 = llvm.extractvalue %99[1] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<2 x i64>, array<2 x i64>)> 
  %124 = llvm.extractvalue %99[2] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<2 x i64>, array<2 x i64>)> 
  %125 = llvm.extractvalue %99[4, 0] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<2 x i64>, array<2 x i64>)> 
  %126 = llvm.mul %125, %22  : i64
  %127 = llvm.add %124, %126  : i64
  %128 = llvm.add %127, %22  : i64
  %129 = llvm.getelementptr %123[%128] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8>
  %130 = llvm.bitcast %129 : !llvm.ptr<i8> to !llvm.ptr<vector<8xi8>>
  %131 = llvm.load %130 {alignment = 4 : i64} : !llvm.ptr<vector<8xi8>>
  %132 = llvm.mul %125, %25  : i64
  %133 = llvm.add %124, %132  : i64
  %134 = llvm.add %133, %22  : i64
  %135 = llvm.getelementptr %123[%134] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8>
  %136 = llvm.bitcast %135 : !llvm.ptr<i8> to !llvm.ptr<vector<8xi8>>
  %137 = llvm.load %136 {alignment = 4 : i64} : !llvm.ptr<vector<8xi8>>
  %138 = llvm.mul %125, %23  : i64
  %139 = llvm.add %124, %138  : i64
  %140 = llvm.add %139, %22  : i64
  %141 = llvm.getelementptr %123[%140] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8>
  %142 = llvm.bitcast %141 : !llvm.ptr<i8> to !llvm.ptr<vector<8xi8>>
  %143 = llvm.load %142 {alignment = 4 : i64} : !llvm.ptr<vector<8xi8>>
  %144 = llvm.mul %125, %16  : i64
  %145 = llvm.add %124, %144  : i64
  %146 = llvm.add %145, %22  : i64
  %147 = llvm.getelementptr %123[%146] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8>
  %148 = llvm.bitcast %147 : !llvm.ptr<i8> to !llvm.ptr<vector<8xi8>>
  %149 = llvm.load %148 {alignment = 4 : i64} : !llvm.ptr<vector<8xi8>>
  %150 = llvm.extractelement %131[%15 : i64] : vector<8xi8>
  %151 = llvm.extractvalue %20[0] : !llvm.array<8 x vector<4xi8>> 
  %152 = llvm.insertelement %150, %151[%15 : i64] : vector<4xi8>
  %153 = llvm.extractelement %131[%12 : i64] : vector<8xi8>
  %154 = llvm.extractvalue %20[1] : !llvm.array<8 x vector<4xi8>> 
  %155 = llvm.insertelement %153, %154[%15 : i64] : vector<4xi8>
  %156 = llvm.extractelement %131[%6 : i64] : vector<8xi8>
  %157 = llvm.extractvalue %20[2] : !llvm.array<8 x vector<4xi8>> 
  %158 = llvm.insertelement %156, %157[%15 : i64] : vector<4xi8>
  %159 = llvm.extractelement %131[%5 : i64] : vector<8xi8>
  %160 = llvm.extractvalue %20[3] : !llvm.array<8 x vector<4xi8>> 
  %161 = llvm.insertelement %159, %160[%15 : i64] : vector<4xi8>
  %162 = llvm.extractelement %131[%4 : i64] : vector<8xi8>
  %163 = llvm.extractvalue %20[4] : !llvm.array<8 x vector<4xi8>> 
  %164 = llvm.insertelement %162, %163[%15 : i64] : vector<4xi8>
  %165 = llvm.extractelement %131[%3 : i64] : vector<8xi8>
  %166 = llvm.extractvalue %20[5] : !llvm.array<8 x vector<4xi8>> 
  %167 = llvm.insertelement %165, %166[%15 : i64] : vector<4xi8>
  %168 = llvm.extractelement %131[%2 : i64] : vector<8xi8>
  %169 = llvm.extractvalue %20[6] : !llvm.array<8 x vector<4xi8>> 
  %170 = llvm.insertelement %168, %169[%15 : i64] : vector<4xi8>
  %171 = llvm.extractelement %131[%1 : i64] : vector<8xi8>
  %172 = llvm.extractvalue %20[7] : !llvm.array<8 x vector<4xi8>> 
  %173 = llvm.insertelement %171, %172[%15 : i64] : vector<4xi8>
  %174 = llvm.extractelement %137[%15 : i64] : vector<8xi8>
  %175 = llvm.insertelement %174, %152[%12 : i64] : vector<4xi8>
  %176 = llvm.extractelement %137[%12 : i64] : vector<8xi8>
  %177 = llvm.insertelement %176, %155[%12 : i64] : vector<4xi8>
  %178 = llvm.extractelement %137[%6 : i64] : vector<8xi8>
  %179 = llvm.insertelement %178, %158[%12 : i64] : vector<4xi8>
  %180 = llvm.extractelement %137[%5 : i64] : vector<8xi8>
  %181 = llvm.insertelement %180, %161[%12 : i64] : vector<4xi8>
  %182 = llvm.extractelement %137[%4 : i64] : vector<8xi8>
  %183 = llvm.insertelement %182, %164[%12 : i64] : vector<4xi8>
  %184 = llvm.extractelement %137[%3 : i64] : vector<8xi8>
  %185 = llvm.insertelement %184, %167[%12 : i64] : vector<4xi8>
  %186 = llvm.extractelement %137[%2 : i64] : vector<8xi8>
  %187 = llvm.insertelement %186, %170[%12 : i64] : vector<4xi8>
  %188 = llvm.extractelement %137[%1 : i64] : vector<8xi8>
  %189 = llvm.insertelement %188, %173[%12 : i64] : vector<4xi8>
  %190 = llvm.extractelement %143[%15 : i64] : vector<8xi8>
  %191 = llvm.insertelement %190, %175[%6 : i64] : vector<4xi8>
  %192 = llvm.extractelement %143[%12 : i64] : vector<8xi8>
  %193 = llvm.insertelement %192, %177[%6 : i64] : vector<4xi8>
  %194 = llvm.extractelement %143[%6 : i64] : vector<8xi8>
  %195 = llvm.insertelement %194, %179[%6 : i64] : vector<4xi8>
  %196 = llvm.extractelement %143[%5 : i64] : vector<8xi8>
  %197 = llvm.insertelement %196, %181[%6 : i64] : vector<4xi8>
  %198 = llvm.extractelement %143[%4 : i64] : vector<8xi8>
  %199 = llvm.insertelement %198, %183[%6 : i64] : vector<4xi8>
  %200 = llvm.extractelement %143[%3 : i64] : vector<8xi8>
  %201 = llvm.insertelement %200, %185[%6 : i64] : vector<4xi8>
  %202 = llvm.extractelement %143[%2 : i64] : vector<8xi8>
  %203 = llvm.insertelement %202, %187[%6 : i64] : vector<4xi8>
  %204 = llvm.extractelement %143[%1 : i64] : vector<8xi8>
  %205 = llvm.insertelement %204, %189[%6 : i64] : vector<4xi8>
  %206 = llvm.extractelement %149[%15 : i64] : vector<8xi8>
  %207 = llvm.insertelement %206, %191[%5 : i64] : vector<4xi8>
  %208 = llvm.extractelement %149[%12 : i64] : vector<8xi8>
  %209 = llvm.insertelement %208, %193[%5 : i64] : vector<4xi8>
  %210 = llvm.extractelement %149[%6 : i64] : vector<8xi8>
  %211 = llvm.insertelement %210, %195[%5 : i64] : vector<4xi8>
  %212 = llvm.extractelement %149[%5 : i64] : vector<8xi8>
  %213 = llvm.insertelement %212, %197[%5 : i64] : vector<4xi8>
  %214 = llvm.extractelement %149[%4 : i64] : vector<8xi8>
  %215 = llvm.insertelement %214, %199[%5 : i64] : vector<4xi8>
  %216 = llvm.extractelement %149[%3 : i64] : vector<8xi8>
  %217 = llvm.insertelement %216, %201[%5 : i64] : vector<4xi8>
  %218 = llvm.extractelement %149[%2 : i64] : vector<8xi8>
  %219 = llvm.insertelement %218, %203[%5 : i64] : vector<4xi8>
  %220 = llvm.extractelement %149[%1 : i64] : vector<8xi8>
  %221 = llvm.insertelement %220, %205[%5 : i64] : vector<4xi8>
  %222 = llvm.mul %22, %11  : i64
  %223 = llvm.add %95, %222  : i64
  %224 = llvm.mul %22, %27  : i64
  %225 = llvm.add %223, %224  : i64
  %226 = llvm.mul %22, %24  : i64
  %227 = llvm.add %225, %226  : i64
  %228 = llvm.add %227, %22  : i64
  %229 = llvm.getelementptr %49[%228] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8>
  %230 = llvm.bitcast %229 : !llvm.ptr<i8> to !llvm.ptr<vector<4xi8>>
  llvm.store %207, %230 {alignment = 4 : i64} : !llvm.ptr<vector<4xi8>>
  %231 = llvm.mul %25, %24  : i64
  %232 = llvm.add %225, %231  : i64
  %233 = llvm.add %232, %22  : i64
  %234 = llvm.getelementptr %49[%233] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8>
  %235 = llvm.bitcast %234 : !llvm.ptr<i8> to !llvm.ptr<vector<4xi8>>
  llvm.store %209, %235 {alignment = 4 : i64} : !llvm.ptr<vector<4xi8>>
  %236 = llvm.mul %23, %24  : i64
  %237 = llvm.add %225, %236  : i64
  %238 = llvm.add %237, %22  : i64
  %239 = llvm.getelementptr %49[%238] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8>
  %240 = llvm.bitcast %239 : !llvm.ptr<i8> to !llvm.ptr<vector<4xi8>>
  llvm.store %211, %240 {alignment = 4 : i64} : !llvm.ptr<vector<4xi8>>
  %241 = llvm.mul %16, %24  : i64
  %242 = llvm.add %225, %241  : i64
  %243 = llvm.add %242, %22  : i64
  %244 = llvm.getelementptr %49[%243] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8>
  %245 = llvm.bitcast %244 : !llvm.ptr<i8> to !llvm.ptr<vector<4xi8>>
  llvm.store %213, %245 {alignment = 4 : i64} : !llvm.ptr<vector<4xi8>>
  %246 = llvm.mul %24, %24  : i64
  %247 = llvm.add %225, %246  : i64
  %248 = llvm.add %247, %22  : i64
  %249 = llvm.getelementptr %49[%248] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8>
  %250 = llvm.bitcast %249 : !llvm.ptr<i8> to !llvm.ptr<vector<4xi8>>
  llvm.store %215, %250 {alignment = 4 : i64} : !llvm.ptr<vector<4xi8>>
  %251 = llvm.mul %17, %24  : i64
  %252 = llvm.add %225, %251  : i64
  %253 = llvm.add %252, %22  : i64
  %254 = llvm.getelementptr %49[%253] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8>
  %255 = llvm.bitcast %254 : !llvm.ptr<i8> to !llvm.ptr<vector<4xi8>>
  llvm.store %217, %255 {alignment = 4 : i64} : !llvm.ptr<vector<4xi8>>
  %256 = llvm.mul %18, %24  : i64
  %257 = llvm.add %225, %256  : i64
  %258 = llvm.add %257, %22  : i64
  %259 = llvm.getelementptr %49[%258] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8>
  %260 = llvm.bitcast %259 : !llvm.ptr<i8> to !llvm.ptr<vector<4xi8>>
  llvm.store %219, %260 {alignment = 4 : i64} : !llvm.ptr<vector<4xi8>>
  %261 = llvm.mul %19, %24  : i64
  %262 = llvm.add %225, %261  : i64
  %263 = llvm.add %262, %22  : i64
  %264 = llvm.getelementptr %49[%263] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8>
  %265 = llvm.bitcast %264 : !llvm.ptr<i8> to !llvm.ptr<vector<4xi8>>
  llvm.store %221, %265 {alignment = 4 : i64} : !llvm.ptr<vector<4xi8>>
  %266 = llvm.add %73, %25  : i64
  llvm.br ^bb5(%266 : i64)
^bb18:  // pred: ^bb5
  %267 = llvm.add %71, %25  : i64
  llvm.br ^bb4(%267 : i64)
^bb19:  // pred: ^bb4
  %268 = llvm.add %69, %68  : i64
  llvm.br ^bb3(%268 : i64)
^bb20:  // pred: ^bb3
  %269 = llvm.add %65, %64  : i64
  llvm.br ^bb1(%269 : i64)
^bb21:  // pred: ^bb1
  llvm.return %0 : i32
}