#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 packforblock20(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;
  w0 = (uint64_t)(in[0] - base);
  w0 |= (uint64_t)(in[1] - base) << 20;
  w0 |= (uint64_t)(in[2] - base) << 40;
  w0 |= (uint64_t)(in[3] - base) << 60;
  w1 = (uint64_t)(in[3] - base) >> 4;
  w1 |= (uint64_t)(in[4] - base) << 16;
  w1 |= (uint64_t)(in[5] - base) << 36;
  w1 |= (uint64_t)(in[6] - base) << 56;
  w2 = (uint64_t)(in[6] - base) >> 8;
  w2 |= (uint64_t)(in[7] - base) << 12;
  w2 |= (uint64_t)(in[8] - base) << 32;
  w2 |= (uint64_t)(in[9] - base) << 52;
  w3 = (uint64_t)(in[9] - base) >> 12;
  w3 |= (uint64_t)(in[10] - base) << 8;
  w3 |= (uint64_t)(in[11] - base) << 28;
  w3 |= (uint64_t)(in[12] - base) << 48;
  w4 = (uint64_t)(in[12] - base) >> 16;
  w4 |= (uint64_t)(in[13] - base) << 4;
  w4 |= (uint64_t)(in[14] - base) << 24;
  w4 |= (uint64_t)(in[15] - base) << 44;
  w5 = (uint64_t)(in[16] - base);
  w5 |= (uint64_t)(in[17] - base) << 20;
  w5 |= (uint64_t)(in[18] - base) << 40;
  w5 |= (uint64_t)(in[19] - base) << 60;
  w6 = (uint64_t)(in[19] - base) >> 4;
  w6 |= (uint64_t)(in[20] - base) << 16;
  w6 |= (uint64_t)(in[21] - base) << 36;
  w6 |= (uint64_t)(in[22] - base) << 56;
  w7 = (uint64_t)(in[22] - base) >> 8;
  w7 |= (uint64_t)(in[23] - base) << 12;
  w7 |= (uint64_t)(in[24] - base) << 32;
  w7 |= (uint64_t)(in[25] - base) << 52;
  w8 = (uint64_t)(in[25] - base) >> 12;
  w8 |= (uint64_t)(in[26] - base) << 8;
  w8 |= (uint64_t)(in[27] - base) << 28;
  w8 |= (uint64_t)(in[28] - base) << 48;
  w9 = (uint64_t)(in[28] - base) >> 16;
  w9 |= (uint64_t)(in[29] - base) << 4;
  w9 |= (uint64_t)(in[30] - base) << 24;
  w9 |= (uint64_t)(in[31] - base) << 44;
  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;
  *pin += 32;
  *pw += 80;
}


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

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

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

LLVM IR (-O2):
define void @packforblock20(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 80
store i32* %7, i32** %2
ret void
}