#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 uint8_t;
typedef int uint64_t;
typedef char const uint32_t;

/* Variables and functions */
int /*<<< orphan*/ salsa20_words(char const *, char const *);
void salsa20_block(uint8_t *out, uint8_t key[32], uint64_t nonce,
                   uint64_t index) {
  static const char c[16] = "expand 32-byte k";
  uint32_t in[16] = {
      ((c)[0] | ((c)[1] << 8) | ((c)[2] << 16) | ((c)[3] << 24)),
      ((key)[0] | ((key)[1] << 8) | ((key)[2] << 16) | ((key)[3] << 24)),
      ((key + 4)[0] | ((key + 4)[1] << 8) | ((key + 4)[2] << 16) |
       ((key + 4)[3] << 24)),
      ((key + 8)[0] | ((key + 8)[1] << 8) | ((key + 8)[2] << 16) |
       ((key + 8)[3] << 24)),
      ((key + 12)[0] | ((key + 12)[1] << 8) | ((key + 12)[2] << 16) |
       ((key + 12)[3] << 24)),
      ((c + 4)[0] | ((c + 4)[1] << 8) | ((c + 4)[2] << 16) |
       ((c + 4)[3] << 24)),
      nonce & 0xffffffff,
      nonce >> 32,
      index & 0xffffffff,
      index >> 32,
      ((c + 8)[0] | ((c + 8)[1] << 8) | ((c + 8)[2] << 16) |
       ((c + 8)[3] << 24)),
      ((key + 16)[0] | ((key + 16)[1] << 8) | ((key + 16)[2] << 16) |
       ((key + 16)[3] << 24)),
      ((key + 20)[0] | ((key + 20)[1] << 8) | ((key + 20)[2] << 16) |
       ((key + 20)[3] << 24)),
      ((key + 24)[0] | ((key + 24)[1] << 8) | ((key + 24)[2] << 16) |
       ((key + 24)[3] << 24)),
      ((key + 28)[0] | ((key + 28)[1] << 8) | ((key + 28)[2] << 16) |
       ((key + 28)[3] << 24)),
      ((c + 12)[0] | ((c + 12)[1] << 8) | ((c + 12)[2] << 16) |
       ((c + 12)[3] << 24))};
  uint32_t wordout[16];
  salsa20_words(wordout, in);
  int i;
  for (i = 0; i < 64; ++i)
    out[i] = 0xff & (wordout[i / 4] >> (8 * (i % 4)));
}


x86 assembly (clang, -O0):
<salsa20_block>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
movsbl 0xed3(%rip),%eax
movsbl 0xecd(%rip),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
movsbl 0xec2(%rip),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
movsbl 0xeb7(%rip),%ecx
shl    $0x18,%ecx
or     %ecx,%eax
mov    %al,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    -0x10(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    0xc(%rcx),%ecx
shl    $0x18,%ecx
or     %ecx,%eax
mov    %al,-0x2f(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%eax
mov    -0x10(%rbp),%rcx
mov    0x14(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    0x18(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    0x1c(%rcx),%ecx
shl    $0x18,%ecx
or     %ecx,%eax
mov    %al,-0x2e(%rbp)
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%eax
mov    -0x10(%rbp),%rcx
mov    0x24(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    0x28(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    0x2c(%rcx),%ecx
shl    $0x18,%ecx
or     %ecx,%eax
mov    %al,-0x2d(%rbp)
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%eax
mov    -0x10(%rbp),%rcx
mov    0x34(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    0x38(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    0x3c(%rcx),%ecx
shl    $0x18,%ecx
or     %ecx,%eax
mov    %al,-0x2c(%rbp)
movsbl 0xdf2(%rip),%eax
movsbl 0xdec(%rip),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
movsbl 0xde1(%rip),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
movsbl 0xdd6(%rip),%ecx
shl    $0x18,%ecx
or     %ecx,%eax
mov    %al,-0x2b(%rbp)
mov    -0x14(%rbp),%eax
and    $0xffffffff,%eax
mov    %al,-0x2a(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x20,%ecx
sar    %cl,%eax
mov    %al,-0x29(%rbp)
mov    -0x18(%rbp),%eax
and    $0xffffffff,%eax
mov    %al,-0x28(%rbp)
mov    -0x18(%rbp),%eax
mov    $0x20,%ecx
sar    %cl,%eax
mov    %al,-0x27(%rbp)
movsbl 0xd9c(%rip),%eax
movsbl 0xd96(%rip),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
movsbl 0xd8b(%rip),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
movsbl 0xd80(%rip),%ecx
shl    $0x18,%ecx
or     %ecx,%eax
mov    %al,-0x26(%rbp)
mov    -0x10(%rbp),%rax
mov    0x40(%rax),%eax
mov    -0x10(%rbp),%rcx
mov    0x44(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    0x48(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    0x4c(%rcx),%ecx
shl    $0x18,%ecx
or     %ecx,%eax
mov    %al,-0x25(%rbp)
mov    -0x10(%rbp),%rax
mov    0x50(%rax),%eax
mov    -0x10(%rbp),%rcx
mov    0x54(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    0x58(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    0x5c(%rcx),%ecx
shl    $0x18,%ecx
or     %ecx,%eax
mov    %al,-0x24(%rbp)
mov    -0x10(%rbp),%rax
mov    0x60(%rax),%eax
mov    -0x10(%rbp),%rcx
mov    0x64(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    0x68(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    0x6c(%rcx),%ecx
shl    $0x18,%ecx
or     %ecx,%eax
mov    %al,-0x23(%rbp)
mov    -0x10(%rbp),%rax
mov    0x70(%rax),%eax
mov    -0x10(%rbp),%rcx
mov    0x74(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    0x78(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    0x7c(%rcx),%ecx
shl    $0x18,%ecx
or     %ecx,%eax
mov    %al,-0x22(%rbp)
movsbl 0xcba(%rip),%eax
movsbl 0xcb4(%rip),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
movsbl 0xca9(%rip),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
movsbl 0xc9e(%rip),%ecx
shl    $0x18,%ecx
or     %ecx,%eax
mov    %al,-0x21(%rbp)
lea    -0x40(%rbp),%rdi
lea    -0x30(%rbp),%rsi
call   1030 <salsa20_words@plt>
movl   $0x0,-0x44(%rbp)
cmpl   $0x40,-0x44(%rbp)
jge    13e0 <salsa20_block+0x2d0>
mov    -0x44(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
cltq
movsbl -0x40(%rbp,%rax,1),%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,%ecx
mov    -0x48(%rbp),%edx
shl    $0x3,%ecx
sar    %cl,%edx
and    $0xff,%edx
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    138d <salsa20_block+0x27d>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<salsa20_block>:
push   %rbx
sub    $0x20,%rsp
mov    %rdi,%rbx
movb   $0x65,(%rsp)
mov    (%rsi),%al
mov    %al,0x1(%rsp)
mov    0x10(%rsi),%al
mov    %al,0x2(%rsp)
mov    0x20(%rsi),%al
mov    %al,0x3(%rsp)
mov    0x30(%rsi),%al
mov    %al,0x4(%rsp)
movb   $0x6e,0x5(%rsp)
mov    %dl,0x6(%rsp)
mov    %cl,0x8(%rsp)
movb   $0x32,0xa(%rsp)
mov    0x40(%rsi),%al
mov    %al,0xb(%rsp)
mov    0x50(%rsi),%al
mov    %al,0xc(%rsp)
mov    0x60(%rsi),%al
mov    %al,0xd(%rsp)
mov    0x70(%rsi),%al
mov    %al,0xe(%rsp)
movb   $0x74,0xf(%rsp)
lea    0x10(%rsp),%rdi
mov    %rsp,%rsi
call   1030 <salsa20_words@plt>
mov    $0x8,%eax
xor    %edx,%edx
xchg   %ax,%ax
mov    %edx,%esi
shr    $0x2,%esi
movsbl 0x10(%rsp,%rsi,1),%edi
lea    -0x8(%rax),%ecx
and    $0x10,%cl
sar    %cl,%edi
movzbl %dil,%ecx
mov    %ecx,(%rbx,%rdx,4)
movsbl 0x10(%rsp,%rsi,1),%esi
mov    %eax,%ecx
and    $0x18,%cl
sar    %cl,%esi
movzbl %sil,%ecx
mov    %ecx,0x4(%rbx,%rdx,4)
add    $0x2,%rdx
add    $0x10,%eax
cmp    $0x40,%rdx
jne    1180 <salsa20_block+0x70>
add    $0x20,%rsp
pop    %rbx
ret

LLVM IR (-O0):
@salsa20_block.c = internal constant [16 x i8] c"expand 32-byte k"
define void @salsa20_block(i32* %0, i32* %1, i32 %2, i32 %3) {
%5 = alloca i32*
%6 = alloca i32*
%7 = alloca i32
%8 = alloca i32
%9 = alloca [16 x i8]
%10 = alloca [16 x i8]
%11 = alloca i32
store i32* %0, i32** %5
store i32* %1, i32** %6
store i32 %2, i32* %7
store i32 %3, i32* %8
%12 = getelementptr inbounds [16 x i8], [16 x i8]* %9, i64 0, i64 0
%13 = load i8, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @salsa20_block.c, i64 0, i64 0)
%14 = sext i8 %13 to i32
%15 = load i8, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @salsa20_block.c, i64 0, i64 1)
%16 = sext i8 %15 to i32
%17 = shl i32 %16, 8
%18 = or i32 %14, %17
%19 = load i8, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @salsa20_block.c, i64 0, i64 2)
%20 = sext i8 %19 to i32
%21 = shl i32 %20, 16
%22 = or i32 %18, %21
%23 = load i8, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @salsa20_block.c, i64 0, i64 3)
%24 = sext i8 %23 to i32
%25 = shl i32 %24, 24
%26 = or i32 %22, %25
%27 = trunc i32 %26 to i8
store i8 %27, i8* %12
%28 = getelementptr inbounds i8, i8* %12, i64 1
%29 = load i32*, i32** %6
%30 = getelementptr inbounds i32, i32* %29, i64 0
%31 = load i32, i32* %30
%32 = load i32*, i32** %6
%33 = getelementptr inbounds i32, i32* %32, i64 1
%34 = load i32, i32* %33
%35 = shl i32 %34, 8
%36 = or i32 %31, %35
%37 = load i32*, i32** %6
%38 = getelementptr inbounds i32, i32* %37, i64 2
%39 = load i32, i32* %38
%40 = shl i32 %39, 16
%41 = or i32 %36, %40
%42 = load i32*, i32** %6
%43 = getelementptr inbounds i32, i32* %42, i64 3
%44 = load i32, i32* %43
%45 = shl i32 %44, 24
%46 = or i32 %41, %45
%47 = trunc i32 %46 to i8
store i8 %47, i8* %28
%48 = getelementptr inbounds i8, i8* %28, i64 1
%49 = load i32*, i32** %6
%50 = getelementptr inbounds i32, i32* %49, i64 4
%51 = getelementptr inbounds i32, i32* %50, i64 0
%52 = load i32, i32* %51
%53 = load i32*, i32** %6
%54 = getelementptr inbounds i32, i32* %53, i64 4
%55 = getelementptr inbounds i32, i32* %54, i64 1
%56 = load i32, i32* %55
%57 = shl i32 %56, 8
%58 = or i32 %52, %57
%59 = load i32*, i32** %6
%60 = getelementptr inbounds i32, i32* %59, i64 4
%61 = getelementptr inbounds i32, i32* %60, i64 2
%62 = load i32, i32* %61
%63 = shl i32 %62, 16
%64 = or i32 %58, %63
%65 = load i32*, i32** %6
%66 = getelementptr inbounds i32, i32* %65, i64 4
%67 = getelementptr inbounds i32, i32* %66, i64 3
%68 = load i32, i32* %67
%69 = shl i32 %68, 24
%70 = or i32 %64, %69
%71 = trunc i32 %70 to i8
store i8 %71, i8* %48
%72 = getelementptr inbounds i8, i8* %48, i64 1
%73 = load i32*, i32** %6
%74 = getelementptr inbounds i32, i32* %73, i64 8
%75 = getelementptr inbounds i32, i32* %74, i64 0
%76 = load i32, i32* %75
%77 = load i32*, i32** %6
%78 = getelementptr inbounds i32, i32* %77, i64 8
%79 = getelementptr inbounds i32, i32* %78, i64 1
%80 = load i32, i32* %79
%81 = shl i32 %80, 8
%82 = or i32 %76, %81
%83 = load i32*, i32** %6
%84 = getelementptr inbounds i32, i32* %83, i64 8
%85 = getelementptr inbounds i32, i32* %84, i64 2
%86 = load i32, i32* %85
%87 = shl i32 %86, 16
%88 = or i32 %82, %87
%89 = load i32*, i32** %6
%90 = getelementptr inbounds i32, i32* %89, i64 8
%91 = getelementptr inbounds i32, i32* %90, i64 3
%92 = load i32, i32* %91
%93 = shl i32 %92, 24
%94 = or i32 %88, %93
%95 = trunc i32 %94 to i8
store i8 %95, i8* %72
%96 = getelementptr inbounds i8, i8* %72, i64 1
%97 = load i32*, i32** %6
%98 = getelementptr inbounds i32, i32* %97, i64 12
%99 = getelementptr inbounds i32, i32* %98, i64 0
%100 = load i32, i32* %99
%101 = load i32*, i32** %6
%102 = getelementptr inbounds i32, i32* %101, i64 12
%103 = getelementptr inbounds i32, i32* %102, i64 1
%104 = load i32, i32* %103
%105 = shl i32 %104, 8
%106 = or i32 %100, %105
%107 = load i32*, i32** %6
%108 = getelementptr inbounds i32, i32* %107, i64 12
%109 = getelementptr inbounds i32, i32* %108, i64 2
%110 = load i32, i32* %109
%111 = shl i32 %110, 16
%112 = or i32 %106, %111
%113 = load i32*, i32** %6
%114 = getelementptr inbounds i32, i32* %113, i64 12
%115 = getelementptr inbounds i32, i32* %114, i64 3
%116 = load i32, i32* %115
%117 = shl i32 %116, 24
%118 = or i32 %112, %117
%119 = trunc i32 %118 to i8
store i8 %119, i8* %96
%120 = getelementptr inbounds i8, i8* %96, i64 1
%121 = load i8, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @salsa20_block.c, i64 0, i64 4)
%122 = sext i8 %121 to i32
%123 = load i8, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @salsa20_block.c, i64 0, i64 5)
%124 = sext i8 %123 to i32
%125 = shl i32 %124, 8
%126 = or i32 %122, %125
%127 = load i8, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @salsa20_block.c, i64 0, i64 6)
%128 = sext i8 %127 to i32
%129 = shl i32 %128, 16
%130 = or i32 %126, %129
%131 = load i8, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @salsa20_block.c, i64 0, i64 7)
%132 = sext i8 %131 to i32
%133 = shl i32 %132, 24
%134 = or i32 %130, %133
%135 = trunc i32 %134 to i8
store i8 %135, i8* %120
%136 = getelementptr inbounds i8, i8* %120, i64 1
%137 = load i32, i32* %7
%138 = and i32 %137, -1
%139 = trunc i32 %138 to i8
store i8 %139, i8* %136
%140 = getelementptr inbounds i8, i8* %136, i64 1
%141 = load i32, i32* %7
%142 = ashr i32 %141, 32
%143 = trunc i32 %142 to i8
store i8 %143, i8* %140
%144 = getelementptr inbounds i8, i8* %140, i64 1
%145 = load i32, i32* %8
%146 = and i32 %145, -1
%147 = trunc i32 %146 to i8
store i8 %147, i8* %144
%148 = getelementptr inbounds i8, i8* %144, i64 1
%149 = load i32, i32* %8
%150 = ashr i32 %149, 32
%151 = trunc i32 %150 to i8
store i8 %151, i8* %148
%152 = getelementptr inbounds i8, i8* %148, i64 1
%153 = load i8, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @salsa20_block.c, i64 0, i64 8)
%154 = sext i8 %153 to i32
%155 = load i8, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @salsa20_block.c, i64 0, i64 9)
%156 = sext i8 %155 to i32
%157 = shl i32 %156, 8
%158 = or i32 %154, %157
%159 = load i8, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @salsa20_block.c, i64 0, i64 10)
%160 = sext i8 %159 to i32
%161 = shl i32 %160, 16
%162 = or i32 %158, %161
%163 = load i8, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @salsa20_block.c, i64 0, i64 11)
%164 = sext i8 %163 to i32
%165 = shl i32 %164, 24
%166 = or i32 %162, %165
%167 = trunc i32 %166 to i8
store i8 %167, i8* %152
%168 = getelementptr inbounds i8, i8* %152, i64 1
%169 = load i32*, i32** %6
%170 = getelementptr inbounds i32, i32* %169, i64 16
%171 = getelementptr inbounds i32, i32* %170, i64 0
%172 = load i32, i32* %171
%173 = load i32*, i32** %6
%174 = getelementptr inbounds i32, i32* %173, i64 16
%175 = getelementptr inbounds i32, i32* %174, i64 1
%176 = load i32, i32* %175
%177 = shl i32 %176, 8
%178 = or i32 %172, %177
%179 = load i32*, i32** %6
%180 = getelementptr inbounds i32, i32* %179, i64 16
%181 = getelementptr inbounds i32, i32* %180, i64 2
%182 = load i32, i32* %181
%183 = shl i32 %182, 16
%184 = or i32 %178, %183
%185 = load i32*, i32** %6
%186 = getelementptr inbounds i32, i32* %185, i64 16
%187 = getelementptr inbounds i32, i32* %186, i64 3
%188 = load i32, i32* %187
%189 = shl i32 %188, 24
%190 = or i32 %184, %189
%191 = trunc i32 %190 to i8
store i8 %191, i8* %168
%192 = getelementptr inbounds i8, i8* %168, i64 1
%193 = load i32*, i32** %6
%194 = getelementptr inbounds i32, i32* %193, i64 20
%195 = getelementptr inbounds i32, i32* %194, i64 0
%196 = load i32, i32* %195
%197 = load i32*, i32** %6
%198 = getelementptr inbounds i32, i32* %197, i64 20
%199 = getelementptr inbounds i32, i32* %198, i64 1
%200 = load i32, i32* %199
%201 = shl i32 %200, 8
%202 = or i32 %196, %201
%203 = load i32*, i32** %6
%204 = getelementptr inbounds i32, i32* %203, i64 20
%205 = getelementptr inbounds i32, i32* %204, i64 2
%206 = load i32, i32* %205
%207 = shl i32 %206, 16
%208 = or i32 %202, %207
%209 = load i32*, i32** %6
%210 = getelementptr inbounds i32, i32* %209, i64 20
%211 = getelementptr inbounds i32, i32* %210, i64 3
%212 = load i32, i32* %211
%213 = shl i32 %212, 24
%214 = or i32 %208, %213
%215 = trunc i32 %214 to i8
store i8 %215, i8* %192
%216 = getelementptr inbounds i8, i8* %192, i64 1
%217 = load i32*, i32** %6
%218 = getelementptr inbounds i32, i32* %217, i64 24
%219 = getelementptr inbounds i32, i32* %218, i64 0
%220 = load i32, i32* %219
%221 = load i32*, i32** %6
%222 = getelementptr inbounds i32, i32* %221, i64 24
%223 = getelementptr inbounds i32, i32* %222, i64 1
%224 = load i32, i32* %223
%225 = shl i32 %224, 8
%226 = or i32 %220, %225
%227 = load i32*, i32** %6
%228 = getelementptr inbounds i32, i32* %227, i64 24
%229 = getelementptr inbounds i32, i32* %228, i64 2
%230 = load i32, i32* %229
%231 = shl i32 %230, 16
%232 = or i32 %226, %231
%233 = load i32*, i32** %6
%234 = getelementptr inbounds i32, i32* %233, i64 24
%235 = getelementptr inbounds i32, i32* %234, i64 3
%236 = load i32, i32* %235
%237 = shl i32 %236, 24
%238 = or i32 %232, %237
%239 = trunc i32 %238 to i8
store i8 %239, i8* %216
%240 = getelementptr inbounds i8, i8* %216, i64 1
%241 = load i32*, i32** %6
%242 = getelementptr inbounds i32, i32* %241, i64 28
%243 = getelementptr inbounds i32, i32* %242, i64 0
%244 = load i32, i32* %243
%245 = load i32*, i32** %6
%246 = getelementptr inbounds i32, i32* %245, i64 28
%247 = getelementptr inbounds i32, i32* %246, i64 1
%248 = load i32, i32* %247
%249 = shl i32 %248, 8
%250 = or i32 %244, %249
%251 = load i32*, i32** %6
%252 = getelementptr inbounds i32, i32* %251, i64 28
%253 = getelementptr inbounds i32, i32* %252, i64 2
%254 = load i32, i32* %253
%255 = shl i32 %254, 16
%256 = or i32 %250, %255
%257 = load i32*, i32** %6
%258 = getelementptr inbounds i32, i32* %257, i64 28
%259 = getelementptr inbounds i32, i32* %258, i64 3
%260 = load i32, i32* %259
%261 = shl i32 %260, 24
%262 = or i32 %256, %261
%263 = trunc i32 %262 to i8
store i8 %263, i8* %240
%264 = getelementptr inbounds i8, i8* %240, i64 1
%265 = load i8, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @salsa20_block.c, i64 0, i64 12)
%266 = sext i8 %265 to i32
%267 = load i8, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @salsa20_block.c, i64 0, i64 13)
%268 = sext i8 %267 to i32
%269 = shl i32 %268, 8
%270 = or i32 %266, %269
%271 = load i8, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @salsa20_block.c, i64 0, i64 14)
%272 = sext i8 %271 to i32
%273 = shl i32 %272, 16
%274 = or i32 %270, %273
%275 = load i8, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @salsa20_block.c, i64 0, i64 15)
%276 = sext i8 %275 to i32
%277 = shl i32 %276, 24
%278 = or i32 %274, %277
%279 = trunc i32 %278 to i8
store i8 %279, i8* %264
%280 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 0
%281 = getelementptr inbounds [16 x i8], [16 x i8]* %9, i64 0, i64 0
%282 = call i32 @salsa20_words(i8* %280, i8* %281)
store i32 0, i32* %11
br label %283
283: ; preds = %302, %4
%284 = load i32, i32* %11
%285 = icmp slt i32 %284, 64
br i1 %285, label %286, label %305
286: ; preds = %283
%287 = load i32, i32* %11
%288 = sdiv i32 %287, 4
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 %289
%291 = load i8, i8* %290
%292 = sext i8 %291 to i32
%293 = load i32, i32* %11
%294 = srem i32 %293, 4
%295 = mul nsw i32 8, %294
%296 = ashr i32 %292, %295
%297 = and i32 255, %296
%298 = load i32*, i32** %5
%299 = load i32, i32* %11
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds i32, i32* %298, i64 %300
store i32 %297, i32* %301
br label %302
302: ; preds = %286
%303 = load i32, i32* %11
%304 = add nsw i32 %303, 1
store i32 %304, i32* %11
br label %283
305: ; preds = %283
ret void
}

LLVM IR (-O2):
define void @salsa20_block(i32* nocapture writeonly %0, i32* nocapture %1, i32 %2, i32 %3) {
%5 = alloca [16 x i8]
%6 = alloca [16 x i8]
%7 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 0
store i8 101, i8* %7
%8 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 1
%9 = load i32, i32* %1
%10 = trunc i32 %9 to i8
store i8 %10, i8* %8
%11 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 2
%12 = getelementptr inbounds i32, i32* %1, i64 4
%13 = load i32, i32* %12
%14 = trunc i32 %13 to i8
store i8 %14, i8* %11
%15 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 3
%16 = getelementptr inbounds i32, i32* %1, i64 8
%17 = load i32, i32* %16
%18 = trunc i32 %17 to i8
store i8 %18, i8* %15
%19 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 4
%20 = getelementptr inbounds i32, i32* %1, i64 12
%21 = load i32, i32* %20
%22 = trunc i32 %21 to i8
store i8 %22, i8* %19
%23 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 5
store i8 110, i8* %23
%24 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 6
%25 = trunc i32 %2 to i8
store i8 %25, i8* %24
%26 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 8
%27 = trunc i32 %3 to i8
store i8 %27, i8* %26
%28 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 10
store i8 50, i8* %28
%29 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 11
%30 = getelementptr inbounds i32, i32* %1, i64 16
%31 = load i32, i32* %30
%32 = trunc i32 %31 to i8
store i8 %32, i8* %29
%33 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 12
%34 = getelementptr inbounds i32, i32* %1, i64 20
%35 = load i32, i32* %34
%36 = trunc i32 %35 to i8
store i8 %36, i8* %33
%37 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 13
%38 = getelementptr inbounds i32, i32* %1, i64 24
%39 = load i32, i32* %38
%40 = trunc i32 %39 to i8
store i8 %40, i8* %37
%41 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 14
%42 = getelementptr inbounds i32, i32* %1, i64 28
%43 = load i32, i32* %42
%44 = trunc i32 %43 to i8
store i8 %44, i8* %41
%45 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 15
store i8 116, i8* %45
%46 = getelementptr inbounds [16 x i8], [16 x i8]* %6, i64 0, i64 0
%47 = call i32 @salsa20_words(i8* %46, i8* %7)
br label %48
48: ; preds = %48, %4
%49 = phi i64 [ 0, %4 ], [ %73, %48 ]
%50 = lshr i64 %49, 2
%51 = and i64 %50, 1073741823
%52 = getelementptr inbounds [16 x i8], [16 x i8]* %6, i64 0, i64 %51
%53 = load i8, i8* %52
%54 = sext i8 %53 to i32
%55 = trunc i64 %49 to i32
%56 = shl i32 %55, 3
%57 = and i32 %56, 16
%58 = ashr i32 %54, %57
%59 = and i32 %58, 255
%60 = getelementptr inbounds i32, i32* %0, i64 %49
store i32 %59, i32* %60
%61 = or i64 %49, 1
%62 = lshr i64 %49, 2
%63 = and i64 %62, 1073741823
%64 = getelementptr inbounds [16 x i8], [16 x i8]* %6, i64 0, i64 %63
%65 = load i8, i8* %64
%66 = sext i8 %65 to i32
%67 = trunc i64 %61 to i32
%68 = shl i32 %67, 3
%69 = and i32 %68, 24
%70 = ashr i32 %66, %69
%71 = and i32 %70, 255
%72 = getelementptr inbounds i32, i32* %0, i64 %61
store i32 %71, i32* %72
%73 = add nuw nsw i64 %49, 2
%74 = icmp eq i64 %73, 64
br i1 %74, label %75, label %48
75: ; preds = %48
ret void
}