#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ uint8_t;
typedef int uint64_t;
typedef scalar_t__ uint32_t;

/* Variables and functions */
void packforblock24(const uint32_t base, const uint32_t **pin, uint8_t **pw) {
  uint64_t *pw64 = *(uint64_t **)pw;
  const uint32_t *in = *pin;
  uint64_t w0;
  uint64_t w1;
  uint64_t w2;
  uint64_t w3;
  uint64_t w4;
  uint64_t w5;
  uint64_t w6;
  uint64_t w7;
  uint64_t w8;
  uint64_t w9;
  uint64_t w10;
  uint64_t w11;
  w0 = (uint64_t)(in[0] - base);
  w0 |= (uint64_t)(in[1] - base) << 24;
  w0 |= (uint64_t)(in[2] - base) << 48;
  w1 = (uint64_t)(in[2] - base) >> 16;
  w1 |= (uint64_t)(in[3] - base) << 8;
  w1 |= (uint64_t)(in[4] - base) << 32;
  w1 |= (uint64_t)(in[5] - base) << 56;
  w2 = (uint64_t)(in[5] - base) >> 8;
  w2 |= (uint64_t)(in[6] - base) << 16;
  w2 |= (uint64_t)(in[7] - base) << 40;
  w3 = (uint64_t)(in[8] - base);
  w3 |= (uint64_t)(in[9] - base) << 24;
  w3 |= (uint64_t)(in[10] - base) << 48;
  w4 = (uint64_t)(in[10] - base) >> 16;
  w4 |= (uint64_t)(in[11] - base) << 8;
  w4 |= (uint64_t)(in[12] - base) << 32;
  w4 |= (uint64_t)(in[13] - base) << 56;
  w5 = (uint64_t)(in[13] - base) >> 8;
  w5 |= (uint64_t)(in[14] - base) << 16;
  w5 |= (uint64_t)(in[15] - base) << 40;
  w6 = (uint64_t)(in[16] - base);
  w6 |= (uint64_t)(in[17] - base) << 24;
  w6 |= (uint64_t)(in[18] - base) << 48;
  w7 = (uint64_t)(in[18] - base) >> 16;
  w7 |= (uint64_t)(in[19] - base) << 8;
  w7 |= (uint64_t)(in[20] - base) << 32;
  w7 |= (uint64_t)(in[21] - base) << 56;
  w8 = (uint64_t)(in[21] - base) >> 8;
  w8 |= (uint64_t)(in[22] - base) << 16;
  w8 |= (uint64_t)(in[23] - base) << 40;
  w9 = (uint64_t)(in[24] - base);
  w9 |= (uint64_t)(in[25] - base) << 24;
  w9 |= (uint64_t)(in[26] - base) << 48;
  w10 = (uint64_t)(in[26] - base) >> 16;
  w10 |= (uint64_t)(in[27] - base) << 8;
  w10 |= (uint64_t)(in[28] - base) << 32;
  w10 |= (uint64_t)(in[29] - base) << 56;
  w11 = (uint64_t)(in[29] - base) >> 8;
  w11 |= (uint64_t)(in[30] - base) << 16;
  w11 |= (uint64_t)(in[31] - base) << 40;
  pw64[0] = w0;
  pw64[1] = w1;
  pw64[2] = w2;
  pw64[3] = w3;
  pw64[4] = w4;
  pw64[5] = w5;
  pw64[6] = w6;
  pw64[7] = w7;
  pw64[8] = w8;
  pw64[9] = w9;
  pw64[10] = w10;
  pw64[11] = w11;
  *pin += 32;
  *pw += 96;
}


x86 assembly (clang, -O0):
<packforblock24>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
sub    -0x8(%rbp),%rax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
sub    -0x8(%rbp),%rax
shl    $0x18,%eax
or     -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%rax
mov    0x10(%rax),%rax
sub    -0x8(%rbp),%rax
mov    $0x30,%ecx
shl    %cl,%eax
or     -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%rax
mov    0x10(%rax),%rax
sub    -0x8(%rbp),%rax
sar    $0x10,%eax
mov    %eax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    0x18(%rax),%rax
sub    -0x8(%rbp),%rax
shl    $0x8,%eax
or     -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    0x20(%rax),%rax
sub    -0x8(%rbp),%rax
mov    $0x20,%ecx
shl    %cl,%eax
or     -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    0x28(%rax),%rax
sub    -0x8(%rbp),%rax
mov    $0x38,%ecx
shl    %cl,%eax
or     -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    0x28(%rax),%rax
sub    -0x8(%rbp),%rax
sar    $0x8,%eax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%rax
mov    0x30(%rax),%rax
sub    -0x8(%rbp),%rax
shl    $0x10,%eax
or     -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%rax
mov    0x38(%rax),%rax
sub    -0x8(%rbp),%rax
mov    $0x28,%ecx
shl    %cl,%eax
or     -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%rax
mov    0x40(%rax),%rax
sub    -0x8(%rbp),%rax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    0x48(%rax),%rax
sub    -0x8(%rbp),%rax
shl    $0x18,%eax
or     -0x38(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    0x50(%rax),%rax
sub    -0x8(%rbp),%rax
mov    $0x30,%ecx
shl    %cl,%eax
or     -0x38(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    0x50(%rax),%rax
sub    -0x8(%rbp),%rax
sar    $0x10,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x28(%rbp),%rax
mov    0x58(%rax),%rax
sub    -0x8(%rbp),%rax
shl    $0x8,%eax
or     -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x28(%rbp),%rax
mov    0x60(%rax),%rax
sub    -0x8(%rbp),%rax
mov    $0x20,%ecx
shl    %cl,%eax
or     -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x28(%rbp),%rax
mov    0x68(%rax),%rax
sub    -0x8(%rbp),%rax
mov    $0x38,%ecx
shl    %cl,%eax
or     -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x28(%rbp),%rax
mov    0x68(%rax),%rax
sub    -0x8(%rbp),%rax
sar    $0x8,%eax
mov    %eax,-0x40(%rbp)
mov    -0x28(%rbp),%rax
mov    0x70(%rax),%rax
sub    -0x8(%rbp),%rax
shl    $0x10,%eax
or     -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x28(%rbp),%rax
mov    0x78(%rax),%rax
sub    -0x8(%rbp),%rax
mov    $0x28,%ecx
shl    %cl,%eax
or     -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x28(%rbp),%rax
mov    0x80(%rax),%rax
sub    -0x8(%rbp),%rax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%rax
mov    0x88(%rax),%rax
sub    -0x8(%rbp),%rax
shl    $0x18,%eax
or     -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%rax
mov    0x90(%rax),%rax
sub    -0x8(%rbp),%rax
mov    $0x30,%ecx
shl    %cl,%eax
or     -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%rax
mov    0x90(%rax),%rax
sub    -0x8(%rbp),%rax
sar    $0x10,%eax
mov    %eax,-0x48(%rbp)
mov    -0x28(%rbp),%rax
mov    0x98(%rax),%rax
sub    -0x8(%rbp),%rax
shl    $0x8,%eax
or     -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x28(%rbp),%rax
mov    0xa0(%rax),%rax
sub    -0x8(%rbp),%rax
mov    $0x20,%ecx
shl    %cl,%eax
or     -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x28(%rbp),%rax
mov    0xa8(%rax),%rax
sub    -0x8(%rbp),%rax
mov    $0x38,%ecx
shl    %cl,%eax
or     -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x28(%rbp),%rax
mov    0xa8(%rax),%rax
sub    -0x8(%rbp),%rax
sar    $0x8,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x28(%rbp),%rax
mov    0xb0(%rax),%rax
sub    -0x8(%rbp),%rax
shl    $0x10,%eax
or     -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x28(%rbp),%rax
mov    0xb8(%rax),%rax
sub    -0x8(%rbp),%rax
mov    $0x28,%ecx
shl    %cl,%eax
or     -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x28(%rbp),%rax
mov    0xc0(%rax),%rax
sub    -0x8(%rbp),%rax
mov    %eax,-0x50(%rbp)
mov    -0x28(%rbp),%rax
mov    0xc8(%rax),%rax
sub    -0x8(%rbp),%rax
shl    $0x18,%eax
or     -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x28(%rbp),%rax
mov    0xd0(%rax),%rax
sub    -0x8(%rbp),%rax
mov    $0x30,%ecx
shl    %cl,%eax
or     -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x28(%rbp),%rax
mov    0xd0(%rax),%rax
sub    -0x8(%rbp),%rax
sar    $0x10,%eax
mov    %eax,-0x54(%rbp)
mov    -0x28(%rbp),%rax
mov    0xd8(%rax),%rax
sub    -0x8(%rbp),%rax
shl    $0x8,%eax
or     -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x28(%rbp),%rax
mov    0xe0(%rax),%rax
sub    -0x8(%rbp),%rax
mov    $0x20,%ecx
shl    %cl,%eax
or     -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x28(%rbp),%rax
mov    0xe8(%rax),%rax
sub    -0x8(%rbp),%rax
mov    $0x38,%ecx
shl    %cl,%eax
or     -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x28(%rbp),%rax
mov    0xe8(%rax),%rax
sub    -0x8(%rbp),%rax
sar    $0x8,%eax
mov    %eax,-0x58(%rbp)
mov    -0x28(%rbp),%rax
mov    0xf0(%rax),%rax
sub    -0x8(%rbp),%rax
shl    $0x10,%eax
or     -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x28(%rbp),%rax
mov    0xf8(%rax),%rax
sub    -0x8(%rbp),%rax
mov    $0x28,%ecx
shl    %cl,%eax
or     -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x30(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x34(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x38(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,0xc(%rax)
mov    -0x3c(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0x40(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,0x14(%rax)
mov    -0x44(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,0x18(%rax)
mov    -0x48(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,0x1c(%rax)
mov    -0x4c(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,0x20(%rax)
mov    -0x50(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,0x24(%rax)
mov    -0x54(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,0x28(%rax)
mov    -0x58(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,0x2c(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x100,%rcx
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%rcx
add    $0x180,%rcx
mov    %rcx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<packforblock24>:
addq   $0x100,(%rsi)
addq   $0x180,(%rdx)
ret

LLVM IR (-O0):
define void @packforblock24(i64 %0, i64** %1, i32** %2) {
%4 = alloca i64
%5 = alloca i64**
%6 = alloca i32**
%7 = alloca i32*
%8 = alloca i64*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
store i64 %0, i64* %4
store i64** %1, i64*** %5
store i32** %2, i32*** %6
%21 = load i32**, i32*** %6
%22 = load i32*, i32** %21
store i32* %22, i32** %7
%23 = load i64**, i64*** %5
%24 = load i64*, i64** %23
store i64* %24, i64** %8
%25 = load i64*, i64** %8
%26 = getelementptr inbounds i64, i64* %25, i64 0
%27 = load i64, i64* %26
%28 = load i64, i64* %4
%29 = sub nsw i64 %27, %28
%30 = trunc i64 %29 to i32
store i32 %30, i32* %9
%31 = load i64*, i64** %8
%32 = getelementptr inbounds i64, i64* %31, i64 1
%33 = load i64, i64* %32
%34 = load i64, i64* %4
%35 = sub nsw i64 %33, %34
%36 = trunc i64 %35 to i32
%37 = shl i32 %36, 24
%38 = load i32, i32* %9
%39 = or i32 %38, %37
store i32 %39, i32* %9
%40 = load i64*, i64** %8
%41 = getelementptr inbounds i64, i64* %40, i64 2
%42 = load i64, i64* %41
%43 = load i64, i64* %4
%44 = sub nsw i64 %42, %43
%45 = trunc i64 %44 to i32
%46 = shl i32 %45, 48
%47 = load i32, i32* %9
%48 = or i32 %47, %46
store i32 %48, i32* %9
%49 = load i64*, i64** %8
%50 = getelementptr inbounds i64, i64* %49, i64 2
%51 = load i64, i64* %50
%52 = load i64, i64* %4
%53 = sub nsw i64 %51, %52
%54 = trunc i64 %53 to i32
%55 = ashr i32 %54, 16
store i32 %55, i32* %10
%56 = load i64*, i64** %8
%57 = getelementptr inbounds i64, i64* %56, i64 3
%58 = load i64, i64* %57
%59 = load i64, i64* %4
%60 = sub nsw i64 %58, %59
%61 = trunc i64 %60 to i32
%62 = shl i32 %61, 8
%63 = load i32, i32* %10
%64 = or i32 %63, %62
store i32 %64, i32* %10
%65 = load i64*, i64** %8
%66 = getelementptr inbounds i64, i64* %65, i64 4
%67 = load i64, i64* %66
%68 = load i64, i64* %4
%69 = sub nsw i64 %67, %68
%70 = trunc i64 %69 to i32
%71 = shl i32 %70, 32
%72 = load i32, i32* %10
%73 = or i32 %72, %71
store i32 %73, i32* %10
%74 = load i64*, i64** %8
%75 = getelementptr inbounds i64, i64* %74, i64 5
%76 = load i64, i64* %75
%77 = load i64, i64* %4
%78 = sub nsw i64 %76, %77
%79 = trunc i64 %78 to i32
%80 = shl i32 %79, 56
%81 = load i32, i32* %10
%82 = or i32 %81, %80
store i32 %82, i32* %10
%83 = load i64*, i64** %8
%84 = getelementptr inbounds i64, i64* %83, i64 5
%85 = load i64, i64* %84
%86 = load i64, i64* %4
%87 = sub nsw i64 %85, %86
%88 = trunc i64 %87 to i32
%89 = ashr i32 %88, 8
store i32 %89, i32* %11
%90 = load i64*, i64** %8
%91 = getelementptr inbounds i64, i64* %90, i64 6
%92 = load i64, i64* %91
%93 = load i64, i64* %4
%94 = sub nsw i64 %92, %93
%95 = trunc i64 %94 to i32
%96 = shl i32 %95, 16
%97 = load i32, i32* %11
%98 = or i32 %97, %96
store i32 %98, i32* %11
%99 = load i64*, i64** %8
%100 = getelementptr inbounds i64, i64* %99, i64 7
%101 = load i64, i64* %100
%102 = load i64, i64* %4
%103 = sub nsw i64 %101, %102
%104 = trunc i64 %103 to i32
%105 = shl i32 %104, 40
%106 = load i32, i32* %11
%107 = or i32 %106, %105
store i32 %107, i32* %11
%108 = load i64*, i64** %8
%109 = getelementptr inbounds i64, i64* %108, i64 8
%110 = load i64, i64* %109
%111 = load i64, i64* %4
%112 = sub nsw i64 %110, %111
%113 = trunc i64 %112 to i32
store i32 %113, i32* %12
%114 = load i64*, i64** %8
%115 = getelementptr inbounds i64, i64* %114, i64 9
%116 = load i64, i64* %115
%117 = load i64, i64* %4
%118 = sub nsw i64 %116, %117
%119 = trunc i64 %118 to i32
%120 = shl i32 %119, 24
%121 = load i32, i32* %12
%122 = or i32 %121, %120
store i32 %122, i32* %12
%123 = load i64*, i64** %8
%124 = getelementptr inbounds i64, i64* %123, i64 10
%125 = load i64, i64* %124
%126 = load i64, i64* %4
%127 = sub nsw i64 %125, %126
%128 = trunc i64 %127 to i32
%129 = shl i32 %128, 48
%130 = load i32, i32* %12
%131 = or i32 %130, %129
store i32 %131, i32* %12
%132 = load i64*, i64** %8
%133 = getelementptr inbounds i64, i64* %132, i64 10
%134 = load i64, i64* %133
%135 = load i64, i64* %4
%136 = sub nsw i64 %134, %135
%137 = trunc i64 %136 to i32
%138 = ashr i32 %137, 16
store i32 %138, i32* %13
%139 = load i64*, i64** %8
%140 = getelementptr inbounds i64, i64* %139, i64 11
%141 = load i64, i64* %140
%142 = load i64, i64* %4
%143 = sub nsw i64 %141, %142
%144 = trunc i64 %143 to i32
%145 = shl i32 %144, 8
%146 = load i32, i32* %13
%147 = or i32 %146, %145
store i32 %147, i32* %13
%148 = load i64*, i64** %8
%149 = getelementptr inbounds i64, i64* %148, i64 12
%150 = load i64, i64* %149
%151 = load i64, i64* %4
%152 = sub nsw i64 %150, %151
%153 = trunc i64 %152 to i32
%154 = shl i32 %153, 32
%155 = load i32, i32* %13
%156 = or i32 %155, %154
store i32 %156, i32* %13
%157 = load i64*, i64** %8
%158 = getelementptr inbounds i64, i64* %157, i64 13
%159 = load i64, i64* %158
%160 = load i64, i64* %4
%161 = sub nsw i64 %159, %160
%162 = trunc i64 %161 to i32
%163 = shl i32 %162, 56
%164 = load i32, i32* %13
%165 = or i32 %164, %163
store i32 %165, i32* %13
%166 = load i64*, i64** %8
%167 = getelementptr inbounds i64, i64* %166, i64 13
%168 = load i64, i64* %167
%169 = load i64, i64* %4
%170 = sub nsw i64 %168, %169
%171 = trunc i64 %170 to i32
%172 = ashr i32 %171, 8
store i32 %172, i32* %14
%173 = load i64*, i64** %8
%174 = getelementptr inbounds i64, i64* %173, i64 14
%175 = load i64, i64* %174
%176 = load i64, i64* %4
%177 = sub nsw i64 %175, %176
%178 = trunc i64 %177 to i32
%179 = shl i32 %178, 16
%180 = load i32, i32* %14
%181 = or i32 %180, %179
store i32 %181, i32* %14
%182 = load i64*, i64** %8
%183 = getelementptr inbounds i64, i64* %182, i64 15
%184 = load i64, i64* %183
%185 = load i64, i64* %4
%186 = sub nsw i64 %184, %185
%187 = trunc i64 %186 to i32
%188 = shl i32 %187, 40
%189 = load i32, i32* %14
%190 = or i32 %189, %188
store i32 %190, i32* %14
%191 = load i64*, i64** %8
%192 = getelementptr inbounds i64, i64* %191, i64 16
%193 = load i64, i64* %192
%194 = load i64, i64* %4
%195 = sub nsw i64 %193, %194
%196 = trunc i64 %195 to i32
store i32 %196, i32* %15
%197 = load i64*, i64** %8
%198 = getelementptr inbounds i64, i64* %197, i64 17
%199 = load i64, i64* %198
%200 = load i64, i64* %4
%201 = sub nsw i64 %199, %200
%202 = trunc i64 %201 to i32
%203 = shl i32 %202, 24
%204 = load i32, i32* %15
%205 = or i32 %204, %203
store i32 %205, i32* %15
%206 = load i64*, i64** %8
%207 = getelementptr inbounds i64, i64* %206, i64 18
%208 = load i64, i64* %207
%209 = load i64, i64* %4
%210 = sub nsw i64 %208, %209
%211 = trunc i64 %210 to i32
%212 = shl i32 %211, 48
%213 = load i32, i32* %15
%214 = or i32 %213, %212
store i32 %214, i32* %15
%215 = load i64*, i64** %8
%216 = getelementptr inbounds i64, i64* %215, i64 18
%217 = load i64, i64* %216
%218 = load i64, i64* %4
%219 = sub nsw i64 %217, %218
%220 = trunc i64 %219 to i32
%221 = ashr i32 %220, 16
store i32 %221, i32* %16
%222 = load i64*, i64** %8
%223 = getelementptr inbounds i64, i64* %222, i64 19
%224 = load i64, i64* %223
%225 = load i64, i64* %4
%226 = sub nsw i64 %224, %225
%227 = trunc i64 %226 to i32
%228 = shl i32 %227, 8
%229 = load i32, i32* %16
%230 = or i32 %229, %228
store i32 %230, i32* %16
%231 = load i64*, i64** %8
%232 = getelementptr inbounds i64, i64* %231, i64 20
%233 = load i64, i64* %232
%234 = load i64, i64* %4
%235 = sub nsw i64 %233, %234
%236 = trunc i64 %235 to i32
%237 = shl i32 %236, 32
%238 = load i32, i32* %16
%239 = or i32 %238, %237
store i32 %239, i32* %16
%240 = load i64*, i64** %8
%241 = getelementptr inbounds i64, i64* %240, i64 21
%242 = load i64, i64* %241
%243 = load i64, i64* %4
%244 = sub nsw i64 %242, %243
%245 = trunc i64 %244 to i32
%246 = shl i32 %245, 56
%247 = load i32, i32* %16
%248 = or i32 %247, %246
store i32 %248, i32* %16
%249 = load i64*, i64** %8
%250 = getelementptr inbounds i64, i64* %249, i64 21
%251 = load i64, i64* %250
%252 = load i64, i64* %4
%253 = sub nsw i64 %251, %252
%254 = trunc i64 %253 to i32
%255 = ashr i32 %254, 8
store i32 %255, i32* %17
%256 = load i64*, i64** %8
%257 = getelementptr inbounds i64, i64* %256, i64 22
%258 = load i64, i64* %257
%259 = load i64, i64* %4
%260 = sub nsw i64 %258, %259
%261 = trunc i64 %260 to i32
%262 = shl i32 %261, 16
%263 = load i32, i32* %17
%264 = or i32 %263, %262
store i32 %264, i32* %17
%265 = load i64*, i64** %8
%266 = getelementptr inbounds i64, i64* %265, i64 23
%267 = load i64, i64* %266
%268 = load i64, i64* %4
%269 = sub nsw i64 %267, %268
%270 = trunc i64 %269 to i32
%271 = shl i32 %270, 40
%272 = load i32, i32* %17
%273 = or i32 %272, %271
store i32 %273, i32* %17
%274 = load i64*, i64** %8
%275 = getelementptr inbounds i64, i64* %274, i64 24
%276 = load i64, i64* %275
%277 = load i64, i64* %4
%278 = sub nsw i64 %276, %277
%279 = trunc i64 %278 to i32
store i32 %279, i32* %18
%280 = load i64*, i64** %8
%281 = getelementptr inbounds i64, i64* %280, i64 25
%282 = load i64, i64* %281
%283 = load i64, i64* %4
%284 = sub nsw i64 %282, %283
%285 = trunc i64 %284 to i32
%286 = shl i32 %285, 24
%287 = load i32, i32* %18
%288 = or i32 %287, %286
store i32 %288, i32* %18
%289 = load i64*, i64** %8
%290 = getelementptr inbounds i64, i64* %289, i64 26
%291 = load i64, i64* %290
%292 = load i64, i64* %4
%293 = sub nsw i64 %291, %292
%294 = trunc i64 %293 to i32
%295 = shl i32 %294, 48
%296 = load i32, i32* %18
%297 = or i32 %296, %295
store i32 %297, i32* %18
%298 = load i64*, i64** %8
%299 = getelementptr inbounds i64, i64* %298, i64 26
%300 = load i64, i64* %299
%301 = load i64, i64* %4
%302 = sub nsw i64 %300, %301
%303 = trunc i64 %302 to i32
%304 = ashr i32 %303, 16
store i32 %304, i32* %19
%305 = load i64*, i64** %8
%306 = getelementptr inbounds i64, i64* %305, i64 27
%307 = load i64, i64* %306
%308 = load i64, i64* %4
%309 = sub nsw i64 %307, %308
%310 = trunc i64 %309 to i32
%311 = shl i32 %310, 8
%312 = load i32, i32* %19
%313 = or i32 %312, %311
store i32 %313, i32* %19
%314 = load i64*, i64** %8
%315 = getelementptr inbounds i64, i64* %314, i64 28
%316 = load i64, i64* %315
%317 = load i64, i64* %4
%318 = sub nsw i64 %316, %317
%319 = trunc i64 %318 to i32
%320 = shl i32 %319, 32
%321 = load i32, i32* %19
%322 = or i32 %321, %320
store i32 %322, i32* %19
%323 = load i64*, i64** %8
%324 = getelementptr inbounds i64, i64* %323, i64 29
%325 = load i64, i64* %324
%326 = load i64, i64* %4
%327 = sub nsw i64 %325, %326
%328 = trunc i64 %327 to i32
%329 = shl i32 %328, 56
%330 = load i32, i32* %19
%331 = or i32 %330, %329
store i32 %331, i32* %19
%332 = load i64*, i64** %8
%333 = getelementptr inbounds i64, i64* %332, i64 29
%334 = load i64, i64* %333
%335 = load i64, i64* %4
%336 = sub nsw i64 %334, %335
%337 = trunc i64 %336 to i32
%338 = ashr i32 %337, 8
store i32 %338, i32* %20
%339 = load i64*, i64** %8
%340 = getelementptr inbounds i64, i64* %339, i64 30
%341 = load i64, i64* %340
%342 = load i64, i64* %4
%343 = sub nsw i64 %341, %342
%344 = trunc i64 %343 to i32
%345 = shl i32 %344, 16
%346 = load i32, i32* %20
%347 = or i32 %346, %345
store i32 %347, i32* %20
%348 = load i64*, i64** %8
%349 = getelementptr inbounds i64, i64* %348, i64 31
%350 = load i64, i64* %349
%351 = load i64, i64* %4
%352 = sub nsw i64 %350, %351
%353 = trunc i64 %352 to i32
%354 = shl i32 %353, 40
%355 = load i32, i32* %20
%356 = or i32 %355, %354
store i32 %356, i32* %20
%357 = load i32, i32* %9
%358 = load i32*, i32** %7
%359 = getelementptr inbounds i32, i32* %358, i64 0
store i32 %357, i32* %359
%360 = load i32, i32* %10
%361 = load i32*, i32** %7
%362 = getelementptr inbounds i32, i32* %361, i64 1
store i32 %360, i32* %362
%363 = load i32, i32* %11
%364 = load i32*, i32** %7
%365 = getelementptr inbounds i32, i32* %364, i64 2
store i32 %363, i32* %365
%366 = load i32, i32* %12
%367 = load i32*, i32** %7
%368 = getelementptr inbounds i32, i32* %367, i64 3
store i32 %366, i32* %368
%369 = load i32, i32* %13
%370 = load i32*, i32** %7
%371 = getelementptr inbounds i32, i32* %370, i64 4
store i32 %369, i32* %371
%372 = load i32, i32* %14
%373 = load i32*, i32** %7
%374 = getelementptr inbounds i32, i32* %373, i64 5
store i32 %372, i32* %374
%375 = load i32, i32* %15
%376 = load i32*, i32** %7
%377 = getelementptr inbounds i32, i32* %376, i64 6
store i32 %375, i32* %377
%378 = load i32, i32* %16
%379 = load i32*, i32** %7
%380 = getelementptr inbounds i32, i32* %379, i64 7
store i32 %378, i32* %380
%381 = load i32, i32* %17
%382 = load i32*, i32** %7
%383 = getelementptr inbounds i32, i32* %382, i64 8
store i32 %381, i32* %383
%384 = load i32, i32* %18
%385 = load i32*, i32** %7
%386 = getelementptr inbounds i32, i32* %385, i64 9
store i32 %384, i32* %386
%387 = load i32, i32* %19
%388 = load i32*, i32** %7
%389 = getelementptr inbounds i32, i32* %388, i64 10
store i32 %387, i32* %389
%390 = load i32, i32* %20
%391 = load i32*, i32** %7
%392 = getelementptr inbounds i32, i32* %391, i64 11
store i32 %390, i32* %392
%393 = load i64**, i64*** %5
%394 = load i64*, i64** %393
%395 = getelementptr inbounds i64, i64* %394, i64 32
store i64* %395, i64** %393
%396 = load i32**, i32*** %6
%397 = load i32*, i32** %396
%398 = getelementptr inbounds i32, i32* %397, i64 96
store i32* %398, i32** %396
ret void
}

LLVM IR (-O2):
define void @packforblock24(i64 %0, i64** nocapture %1, i32** nocapture %2) {
%4 = load i64*, i64** %1
%5 = getelementptr inbounds i64, i64* %4, i64 32
store i64* %5, i64** %1
%6 = load i32*, i32** %2
%7 = getelementptr inbounds i32, i32* %6, i64 96
store i32* %7, i32** %2
ret void
}