#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 */

/* Variables and functions */
unsigned short gf4096_inv(unsigned short);
unsigned short gf4096_mul(unsigned short, unsigned short);
void zero_4x5_col3(unsigned short m[4][5]) {
  unsigned short minv1, minv2, minv3;
  minv1 = gf4096_mul(m[1][3], gf4096_inv(m[0][3]));
  minv2 = gf4096_mul(m[2][3], gf4096_inv(m[0][3]));
  minv3 = gf4096_mul(m[3][3], gf4096_inv(m[0][3]));
  m[1][0] = m[1][0] ^ gf4096_mul(m[0][0], minv1);
  m[1][1] = m[1][1] ^ gf4096_mul(m[0][1], minv1);
  m[1][2] = m[1][2] ^ gf4096_mul(m[0][2], minv1);
  m[1][4] = m[1][4] ^ gf4096_mul(m[0][4], minv1);
  m[2][0] = m[2][0] ^ gf4096_mul(m[0][0], minv2);
  m[2][1] = m[2][1] ^ gf4096_mul(m[0][1], minv2);
  m[2][2] = m[2][2] ^ gf4096_mul(m[0][2], minv2);
  m[2][4] = m[2][4] ^ gf4096_mul(m[0][4], minv2);
  m[3][0] = m[3][0] ^ gf4096_mul(m[0][0], minv3);
  m[3][1] = m[3][1] ^ gf4096_mul(m[0][1], minv3);
  m[3][2] = m[3][2] ^ gf4096_mul(m[0][2], minv3);
  m[3][4] = m[3][4] ^ gf4096_mul(m[0][4], minv3);
}


x86 assembly (clang, -O0):
<zero_4x5_col3>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%ax
mov    %ax,-0x46(%rbp)
mov    -0x8(%rbp),%rax
movzwl 0x6(%rax),%edi
call   1040 <gf4096_inv@plt>
mov    -0x46(%rbp),%cx
movzwl %cx,%edi
movzwl %ax,%esi
call   1030 <gf4096_mul@plt>
mov    %ax,-0xa(%rbp)
mov    -0x8(%rbp),%rax
mov    0x1a(%rax),%ax
mov    %ax,-0x44(%rbp)
mov    -0x8(%rbp),%rax
movzwl 0x6(%rax),%edi
call   1040 <gf4096_inv@plt>
mov    -0x44(%rbp),%cx
movzwl %cx,%edi
movzwl %ax,%esi
call   1030 <gf4096_mul@plt>
mov    %ax,-0xc(%rbp)
mov    -0x8(%rbp),%rax
mov    0x24(%rax),%ax
mov    %ax,-0x42(%rbp)
mov    -0x8(%rbp),%rax
movzwl 0x6(%rax),%edi
call   1040 <gf4096_inv@plt>
mov    -0x42(%rbp),%cx
movzwl %cx,%edi
movzwl %ax,%esi
call   1030 <gf4096_mul@plt>
mov    %ax,-0xe(%rbp)
mov    -0x8(%rbp),%rax
movzwl 0xa(%rax),%eax
mov    %eax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%ax
movzwl %ax,%edi
movzwl -0xa(%rbp),%esi
call   1030 <gf4096_mul@plt>
mov    %ax,%cx
mov    -0x40(%rbp),%eax
movzwl %cx,%ecx
xor    %ecx,%eax
mov    %ax,%cx
mov    -0x8(%rbp),%rax
mov    %cx,0xa(%rax)
mov    -0x8(%rbp),%rax
movzwl 0xc(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
mov    0x2(%rax),%ax
movzwl %ax,%edi
movzwl -0xa(%rbp),%esi
call   1030 <gf4096_mul@plt>
mov    %ax,%cx
mov    -0x3c(%rbp),%eax
movzwl %cx,%ecx
xor    %ecx,%eax
mov    %ax,%cx
mov    -0x8(%rbp),%rax
mov    %cx,0xc(%rax)
mov    -0x8(%rbp),%rax
movzwl 0xe(%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%ax
movzwl %ax,%edi
movzwl -0xa(%rbp),%esi
call   1030 <gf4096_mul@plt>
mov    %ax,%cx
mov    -0x38(%rbp),%eax
movzwl %cx,%ecx
xor    %ecx,%eax
mov    %ax,%cx
mov    -0x8(%rbp),%rax
mov    %cx,0xe(%rax)
mov    -0x8(%rbp),%rax
movzwl 0x12(%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%ax
movzwl %ax,%edi
movzwl -0xa(%rbp),%esi
call   1030 <gf4096_mul@plt>
mov    %ax,%cx
mov    -0x34(%rbp),%eax
movzwl %cx,%ecx
xor    %ecx,%eax
mov    %ax,%cx
mov    -0x8(%rbp),%rax
mov    %cx,0x12(%rax)
mov    -0x8(%rbp),%rax
movzwl 0x14(%rax),%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%ax
movzwl %ax,%edi
movzwl -0xc(%rbp),%esi
call   1030 <gf4096_mul@plt>
mov    %ax,%cx
mov    -0x30(%rbp),%eax
movzwl %cx,%ecx
xor    %ecx,%eax
mov    %ax,%cx
mov    -0x8(%rbp),%rax
mov    %cx,0x14(%rax)
mov    -0x8(%rbp),%rax
movzwl 0x16(%rax),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    0x2(%rax),%ax
movzwl %ax,%edi
movzwl -0xc(%rbp),%esi
call   1030 <gf4096_mul@plt>
mov    %ax,%cx
mov    -0x2c(%rbp),%eax
movzwl %cx,%ecx
xor    %ecx,%eax
mov    %ax,%cx
mov    -0x8(%rbp),%rax
mov    %cx,0x16(%rax)
mov    -0x8(%rbp),%rax
movzwl 0x18(%rax),%eax
mov    %eax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%ax
movzwl %ax,%edi
movzwl -0xc(%rbp),%esi
call   1030 <gf4096_mul@plt>
mov    %ax,%cx
mov    -0x28(%rbp),%eax
movzwl %cx,%ecx
xor    %ecx,%eax
mov    %ax,%cx
mov    -0x8(%rbp),%rax
mov    %cx,0x18(%rax)
mov    -0x8(%rbp),%rax
movzwl 0x1c(%rax),%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%ax
movzwl %ax,%edi
movzwl -0xc(%rbp),%esi
call   1030 <gf4096_mul@plt>
mov    %ax,%cx
mov    -0x24(%rbp),%eax
movzwl %cx,%ecx
xor    %ecx,%eax
mov    %ax,%cx
mov    -0x8(%rbp),%rax
mov    %cx,0x1c(%rax)
mov    -0x8(%rbp),%rax
movzwl 0x1e(%rax),%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%ax
movzwl %ax,%edi
movzwl -0xe(%rbp),%esi
call   1030 <gf4096_mul@plt>
mov    %ax,%cx
mov    -0x20(%rbp),%eax
movzwl %cx,%ecx
xor    %ecx,%eax
mov    %ax,%cx
mov    -0x8(%rbp),%rax
mov    %cx,0x1e(%rax)
mov    -0x8(%rbp),%rax
movzwl 0x20(%rax),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
mov    0x2(%rax),%ax
movzwl %ax,%edi
movzwl -0xe(%rbp),%esi
call   1030 <gf4096_mul@plt>
mov    %ax,%cx
mov    -0x1c(%rbp),%eax
movzwl %cx,%ecx
xor    %ecx,%eax
mov    %ax,%cx
mov    -0x8(%rbp),%rax
mov    %cx,0x20(%rax)
mov    -0x8(%rbp),%rax
movzwl 0x22(%rax),%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%ax
movzwl %ax,%edi
movzwl -0xe(%rbp),%esi
call   1030 <gf4096_mul@plt>
mov    %ax,%cx
mov    -0x18(%rbp),%eax
movzwl %cx,%ecx
xor    %ecx,%eax
mov    %ax,%cx
mov    -0x8(%rbp),%rax
mov    %cx,0x22(%rax)
mov    -0x8(%rbp),%rax
movzwl 0x26(%rax),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%ax
movzwl %ax,%edi
movzwl -0xe(%rbp),%esi
call   1030 <gf4096_mul@plt>
mov    %ax,%cx
mov    -0x14(%rbp),%eax
movzwl %cx,%ecx
xor    %ecx,%eax
mov    %ax,%cx
mov    -0x8(%rbp),%rax
mov    %cx,0x26(%rax)
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<zero_4x5_col3>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rdi,%rbx
movzwl 0x10(%rdi),%ebp
movzwl 0x6(%rdi),%edi
call   1040 <gf4096_inv@plt>
movzwl %ax,%esi
mov    %ebp,%edi
call   1030 <gf4096_mul@plt>
mov    %eax,%r12d
movzwl 0x1a(%rbx),%ebp
movzwl 0x6(%rbx),%edi
call   1040 <gf4096_inv@plt>
movzwl %ax,%esi
mov    %ebp,%edi
call   1030 <gf4096_mul@plt>
mov    %eax,%r15d
movzwl 0x24(%rbx),%ebp
movzwl 0x6(%rbx),%edi
call   1040 <gf4096_inv@plt>
movzwl %ax,%esi
mov    %ebp,%edi
call   1030 <gf4096_mul@plt>
mov    %eax,%r14d
movzwl 0xa(%rbx),%r13d
movzwl (%rbx),%edi
movzwl %r12w,%ebp
mov    %ebp,%esi
call   1030 <gf4096_mul@plt>
xor    %r13w,%ax
mov    %ax,0xa(%rbx)
movzwl 0xc(%rbx),%r12d
movzwl 0x2(%rbx),%edi
mov    %ebp,%esi
call   1030 <gf4096_mul@plt>
xor    %r12w,%ax
mov    %ax,0xc(%rbx)
movzwl 0xe(%rbx),%r12d
movzwl 0x4(%rbx),%edi
mov    %ebp,%esi
call   1030 <gf4096_mul@plt>
xor    %r12w,%ax
mov    %ax,0xe(%rbx)
movzwl 0x12(%rbx),%r12d
movzwl 0x8(%rbx),%edi
mov    %ebp,%esi
call   1030 <gf4096_mul@plt>
xor    %r12w,%ax
mov    %ax,0x12(%rbx)
movzwl 0x14(%rbx),%r12d
movzwl (%rbx),%edi
movzwl %r15w,%ebp
mov    %ebp,%esi
call   1030 <gf4096_mul@plt>
xor    %r12w,%ax
mov    %ax,0x14(%rbx)
movzwl 0x16(%rbx),%r15d
movzwl 0x2(%rbx),%edi
mov    %ebp,%esi
call   1030 <gf4096_mul@plt>
xor    %r15w,%ax
mov    %ax,0x16(%rbx)
movzwl 0x18(%rbx),%r15d
movzwl 0x4(%rbx),%edi
mov    %ebp,%esi
call   1030 <gf4096_mul@plt>
xor    %r15w,%ax
mov    %ax,0x18(%rbx)
movzwl 0x1c(%rbx),%r15d
movzwl 0x8(%rbx),%edi
mov    %ebp,%esi
call   1030 <gf4096_mul@plt>
xor    %r15w,%ax
mov    %ax,0x1c(%rbx)
movzwl 0x1e(%rbx),%r15d
movzwl (%rbx),%edi
movzwl %r14w,%ebp
mov    %ebp,%esi
call   1030 <gf4096_mul@plt>
xor    %r15w,%ax
mov    %ax,0x1e(%rbx)
movzwl 0x20(%rbx),%r14d
movzwl 0x2(%rbx),%edi
mov    %ebp,%esi
call   1030 <gf4096_mul@plt>
xor    %r14w,%ax
mov    %ax,0x20(%rbx)
movzwl 0x22(%rbx),%r14d
movzwl 0x4(%rbx),%edi
mov    %ebp,%esi
call   1030 <gf4096_mul@plt>
xor    %r14w,%ax
mov    %ax,0x22(%rbx)
movzwl 0x26(%rbx),%r14d
movzwl 0x8(%rbx),%edi
mov    %ebp,%esi
call   1030 <gf4096_mul@plt>
xor    %r14w,%ax
mov    %ax,0x26(%rbx)
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @zero_4x5_col3([5 x i16]* %0) {
%2 = alloca [5 x i16]*
%3 = alloca i16
%4 = alloca i16
%5 = alloca i16
store [5 x i16]* %0, [5 x i16]** %2
%6 = load [5 x i16]*, [5 x i16]** %2
%7 = getelementptr inbounds [5 x i16], [5 x i16]* %6, i64 1
%8 = getelementptr inbounds [5 x i16], [5 x i16]* %7, i64 0, i64 3
%9 = load i16, i16* %8
%10 = load [5 x i16]*, [5 x i16]** %2
%11 = getelementptr inbounds [5 x i16], [5 x i16]* %10, i64 0
%12 = getelementptr inbounds [5 x i16], [5 x i16]* %11, i64 0, i64 3
%13 = load i16, i16* %12
%14 = call zeroext i16 @gf4096_inv(i16 zeroext %13)
%15 = call zeroext i16 @gf4096_mul(i16 zeroext %9, i16 zeroext %14)
store i16 %15, i16* %3
%16 = load [5 x i16]*, [5 x i16]** %2
%17 = getelementptr inbounds [5 x i16], [5 x i16]* %16, i64 2
%18 = getelementptr inbounds [5 x i16], [5 x i16]* %17, i64 0, i64 3
%19 = load i16, i16* %18
%20 = load [5 x i16]*, [5 x i16]** %2
%21 = getelementptr inbounds [5 x i16], [5 x i16]* %20, i64 0
%22 = getelementptr inbounds [5 x i16], [5 x i16]* %21, i64 0, i64 3
%23 = load i16, i16* %22
%24 = call zeroext i16 @gf4096_inv(i16 zeroext %23)
%25 = call zeroext i16 @gf4096_mul(i16 zeroext %19, i16 zeroext %24)
store i16 %25, i16* %4
%26 = load [5 x i16]*, [5 x i16]** %2
%27 = getelementptr inbounds [5 x i16], [5 x i16]* %26, i64 3
%28 = getelementptr inbounds [5 x i16], [5 x i16]* %27, i64 0, i64 3
%29 = load i16, i16* %28
%30 = load [5 x i16]*, [5 x i16]** %2
%31 = getelementptr inbounds [5 x i16], [5 x i16]* %30, i64 0
%32 = getelementptr inbounds [5 x i16], [5 x i16]* %31, i64 0, i64 3
%33 = load i16, i16* %32
%34 = call zeroext i16 @gf4096_inv(i16 zeroext %33)
%35 = call zeroext i16 @gf4096_mul(i16 zeroext %29, i16 zeroext %34)
store i16 %35, i16* %5
%36 = load [5 x i16]*, [5 x i16]** %2
%37 = getelementptr inbounds [5 x i16], [5 x i16]* %36, i64 1
%38 = getelementptr inbounds [5 x i16], [5 x i16]* %37, i64 0, i64 0
%39 = load i16, i16* %38
%40 = zext i16 %39 to i32
%41 = load [5 x i16]*, [5 x i16]** %2
%42 = getelementptr inbounds [5 x i16], [5 x i16]* %41, i64 0
%43 = getelementptr inbounds [5 x i16], [5 x i16]* %42, i64 0, i64 0
%44 = load i16, i16* %43
%45 = load i16, i16* %3
%46 = call zeroext i16 @gf4096_mul(i16 zeroext %44, i16 zeroext %45)
%47 = zext i16 %46 to i32
%48 = xor i32 %40, %47
%49 = trunc i32 %48 to i16
%50 = load [5 x i16]*, [5 x i16]** %2
%51 = getelementptr inbounds [5 x i16], [5 x i16]* %50, i64 1
%52 = getelementptr inbounds [5 x i16], [5 x i16]* %51, i64 0, i64 0
store i16 %49, i16* %52
%53 = load [5 x i16]*, [5 x i16]** %2
%54 = getelementptr inbounds [5 x i16], [5 x i16]* %53, i64 1
%55 = getelementptr inbounds [5 x i16], [5 x i16]* %54, i64 0, i64 1
%56 = load i16, i16* %55
%57 = zext i16 %56 to i32
%58 = load [5 x i16]*, [5 x i16]** %2
%59 = getelementptr inbounds [5 x i16], [5 x i16]* %58, i64 0
%60 = getelementptr inbounds [5 x i16], [5 x i16]* %59, i64 0, i64 1
%61 = load i16, i16* %60
%62 = load i16, i16* %3
%63 = call zeroext i16 @gf4096_mul(i16 zeroext %61, i16 zeroext %62)
%64 = zext i16 %63 to i32
%65 = xor i32 %57, %64
%66 = trunc i32 %65 to i16
%67 = load [5 x i16]*, [5 x i16]** %2
%68 = getelementptr inbounds [5 x i16], [5 x i16]* %67, i64 1
%69 = getelementptr inbounds [5 x i16], [5 x i16]* %68, i64 0, i64 1
store i16 %66, i16* %69
%70 = load [5 x i16]*, [5 x i16]** %2
%71 = getelementptr inbounds [5 x i16], [5 x i16]* %70, i64 1
%72 = getelementptr inbounds [5 x i16], [5 x i16]* %71, i64 0, i64 2
%73 = load i16, i16* %72
%74 = zext i16 %73 to i32
%75 = load [5 x i16]*, [5 x i16]** %2
%76 = getelementptr inbounds [5 x i16], [5 x i16]* %75, i64 0
%77 = getelementptr inbounds [5 x i16], [5 x i16]* %76, i64 0, i64 2
%78 = load i16, i16* %77
%79 = load i16, i16* %3
%80 = call zeroext i16 @gf4096_mul(i16 zeroext %78, i16 zeroext %79)
%81 = zext i16 %80 to i32
%82 = xor i32 %74, %81
%83 = trunc i32 %82 to i16
%84 = load [5 x i16]*, [5 x i16]** %2
%85 = getelementptr inbounds [5 x i16], [5 x i16]* %84, i64 1
%86 = getelementptr inbounds [5 x i16], [5 x i16]* %85, i64 0, i64 2
store i16 %83, i16* %86
%87 = load [5 x i16]*, [5 x i16]** %2
%88 = getelementptr inbounds [5 x i16], [5 x i16]* %87, i64 1
%89 = getelementptr inbounds [5 x i16], [5 x i16]* %88, i64 0, i64 4
%90 = load i16, i16* %89
%91 = zext i16 %90 to i32
%92 = load [5 x i16]*, [5 x i16]** %2
%93 = getelementptr inbounds [5 x i16], [5 x i16]* %92, i64 0
%94 = getelementptr inbounds [5 x i16], [5 x i16]* %93, i64 0, i64 4
%95 = load i16, i16* %94
%96 = load i16, i16* %3
%97 = call zeroext i16 @gf4096_mul(i16 zeroext %95, i16 zeroext %96)
%98 = zext i16 %97 to i32
%99 = xor i32 %91, %98
%100 = trunc i32 %99 to i16
%101 = load [5 x i16]*, [5 x i16]** %2
%102 = getelementptr inbounds [5 x i16], [5 x i16]* %101, i64 1
%103 = getelementptr inbounds [5 x i16], [5 x i16]* %102, i64 0, i64 4
store i16 %100, i16* %103
%104 = load [5 x i16]*, [5 x i16]** %2
%105 = getelementptr inbounds [5 x i16], [5 x i16]* %104, i64 2
%106 = getelementptr inbounds [5 x i16], [5 x i16]* %105, i64 0, i64 0
%107 = load i16, i16* %106
%108 = zext i16 %107 to i32
%109 = load [5 x i16]*, [5 x i16]** %2
%110 = getelementptr inbounds [5 x i16], [5 x i16]* %109, i64 0
%111 = getelementptr inbounds [5 x i16], [5 x i16]* %110, i64 0, i64 0
%112 = load i16, i16* %111
%113 = load i16, i16* %4
%114 = call zeroext i16 @gf4096_mul(i16 zeroext %112, i16 zeroext %113)
%115 = zext i16 %114 to i32
%116 = xor i32 %108, %115
%117 = trunc i32 %116 to i16
%118 = load [5 x i16]*, [5 x i16]** %2
%119 = getelementptr inbounds [5 x i16], [5 x i16]* %118, i64 2
%120 = getelementptr inbounds [5 x i16], [5 x i16]* %119, i64 0, i64 0
store i16 %117, i16* %120
%121 = load [5 x i16]*, [5 x i16]** %2
%122 = getelementptr inbounds [5 x i16], [5 x i16]* %121, i64 2
%123 = getelementptr inbounds [5 x i16], [5 x i16]* %122, i64 0, i64 1
%124 = load i16, i16* %123
%125 = zext i16 %124 to i32
%126 = load [5 x i16]*, [5 x i16]** %2
%127 = getelementptr inbounds [5 x i16], [5 x i16]* %126, i64 0
%128 = getelementptr inbounds [5 x i16], [5 x i16]* %127, i64 0, i64 1
%129 = load i16, i16* %128
%130 = load i16, i16* %4
%131 = call zeroext i16 @gf4096_mul(i16 zeroext %129, i16 zeroext %130)
%132 = zext i16 %131 to i32
%133 = xor i32 %125, %132
%134 = trunc i32 %133 to i16
%135 = load [5 x i16]*, [5 x i16]** %2
%136 = getelementptr inbounds [5 x i16], [5 x i16]* %135, i64 2
%137 = getelementptr inbounds [5 x i16], [5 x i16]* %136, i64 0, i64 1
store i16 %134, i16* %137
%138 = load [5 x i16]*, [5 x i16]** %2
%139 = getelementptr inbounds [5 x i16], [5 x i16]* %138, i64 2
%140 = getelementptr inbounds [5 x i16], [5 x i16]* %139, i64 0, i64 2
%141 = load i16, i16* %140
%142 = zext i16 %141 to i32
%143 = load [5 x i16]*, [5 x i16]** %2
%144 = getelementptr inbounds [5 x i16], [5 x i16]* %143, i64 0
%145 = getelementptr inbounds [5 x i16], [5 x i16]* %144, i64 0, i64 2
%146 = load i16, i16* %145
%147 = load i16, i16* %4
%148 = call zeroext i16 @gf4096_mul(i16 zeroext %146, i16 zeroext %147)
%149 = zext i16 %148 to i32
%150 = xor i32 %142, %149
%151 = trunc i32 %150 to i16
%152 = load [5 x i16]*, [5 x i16]** %2
%153 = getelementptr inbounds [5 x i16], [5 x i16]* %152, i64 2
%154 = getelementptr inbounds [5 x i16], [5 x i16]* %153, i64 0, i64 2
store i16 %151, i16* %154
%155 = load [5 x i16]*, [5 x i16]** %2
%156 = getelementptr inbounds [5 x i16], [5 x i16]* %155, i64 2
%157 = getelementptr inbounds [5 x i16], [5 x i16]* %156, i64 0, i64 4
%158 = load i16, i16* %157
%159 = zext i16 %158 to i32
%160 = load [5 x i16]*, [5 x i16]** %2
%161 = getelementptr inbounds [5 x i16], [5 x i16]* %160, i64 0
%162 = getelementptr inbounds [5 x i16], [5 x i16]* %161, i64 0, i64 4
%163 = load i16, i16* %162
%164 = load i16, i16* %4
%165 = call zeroext i16 @gf4096_mul(i16 zeroext %163, i16 zeroext %164)
%166 = zext i16 %165 to i32
%167 = xor i32 %159, %166
%168 = trunc i32 %167 to i16
%169 = load [5 x i16]*, [5 x i16]** %2
%170 = getelementptr inbounds [5 x i16], [5 x i16]* %169, i64 2
%171 = getelementptr inbounds [5 x i16], [5 x i16]* %170, i64 0, i64 4
store i16 %168, i16* %171
%172 = load [5 x i16]*, [5 x i16]** %2
%173 = getelementptr inbounds [5 x i16], [5 x i16]* %172, i64 3
%174 = getelementptr inbounds [5 x i16], [5 x i16]* %173, i64 0, i64 0
%175 = load i16, i16* %174
%176 = zext i16 %175 to i32
%177 = load [5 x i16]*, [5 x i16]** %2
%178 = getelementptr inbounds [5 x i16], [5 x i16]* %177, i64 0
%179 = getelementptr inbounds [5 x i16], [5 x i16]* %178, i64 0, i64 0
%180 = load i16, i16* %179
%181 = load i16, i16* %5
%182 = call zeroext i16 @gf4096_mul(i16 zeroext %180, i16 zeroext %181)
%183 = zext i16 %182 to i32
%184 = xor i32 %176, %183
%185 = trunc i32 %184 to i16
%186 = load [5 x i16]*, [5 x i16]** %2
%187 = getelementptr inbounds [5 x i16], [5 x i16]* %186, i64 3
%188 = getelementptr inbounds [5 x i16], [5 x i16]* %187, i64 0, i64 0
store i16 %185, i16* %188
%189 = load [5 x i16]*, [5 x i16]** %2
%190 = getelementptr inbounds [5 x i16], [5 x i16]* %189, i64 3
%191 = getelementptr inbounds [5 x i16], [5 x i16]* %190, i64 0, i64 1
%192 = load i16, i16* %191
%193 = zext i16 %192 to i32
%194 = load [5 x i16]*, [5 x i16]** %2
%195 = getelementptr inbounds [5 x i16], [5 x i16]* %194, i64 0
%196 = getelementptr inbounds [5 x i16], [5 x i16]* %195, i64 0, i64 1
%197 = load i16, i16* %196
%198 = load i16, i16* %5
%199 = call zeroext i16 @gf4096_mul(i16 zeroext %197, i16 zeroext %198)
%200 = zext i16 %199 to i32
%201 = xor i32 %193, %200
%202 = trunc i32 %201 to i16
%203 = load [5 x i16]*, [5 x i16]** %2
%204 = getelementptr inbounds [5 x i16], [5 x i16]* %203, i64 3
%205 = getelementptr inbounds [5 x i16], [5 x i16]* %204, i64 0, i64 1
store i16 %202, i16* %205
%206 = load [5 x i16]*, [5 x i16]** %2
%207 = getelementptr inbounds [5 x i16], [5 x i16]* %206, i64 3
%208 = getelementptr inbounds [5 x i16], [5 x i16]* %207, i64 0, i64 2
%209 = load i16, i16* %208
%210 = zext i16 %209 to i32
%211 = load [5 x i16]*, [5 x i16]** %2
%212 = getelementptr inbounds [5 x i16], [5 x i16]* %211, i64 0
%213 = getelementptr inbounds [5 x i16], [5 x i16]* %212, i64 0, i64 2
%214 = load i16, i16* %213
%215 = load i16, i16* %5
%216 = call zeroext i16 @gf4096_mul(i16 zeroext %214, i16 zeroext %215)
%217 = zext i16 %216 to i32
%218 = xor i32 %210, %217
%219 = trunc i32 %218 to i16
%220 = load [5 x i16]*, [5 x i16]** %2
%221 = getelementptr inbounds [5 x i16], [5 x i16]* %220, i64 3
%222 = getelementptr inbounds [5 x i16], [5 x i16]* %221, i64 0, i64 2
store i16 %219, i16* %222
%223 = load [5 x i16]*, [5 x i16]** %2
%224 = getelementptr inbounds [5 x i16], [5 x i16]* %223, i64 3
%225 = getelementptr inbounds [5 x i16], [5 x i16]* %224, i64 0, i64 4
%226 = load i16, i16* %225
%227 = zext i16 %226 to i32
%228 = load [5 x i16]*, [5 x i16]** %2
%229 = getelementptr inbounds [5 x i16], [5 x i16]* %228, i64 0
%230 = getelementptr inbounds [5 x i16], [5 x i16]* %229, i64 0, i64 4
%231 = load i16, i16* %230
%232 = load i16, i16* %5
%233 = call zeroext i16 @gf4096_mul(i16 zeroext %231, i16 zeroext %232)
%234 = zext i16 %233 to i32
%235 = xor i32 %227, %234
%236 = trunc i32 %235 to i16
%237 = load [5 x i16]*, [5 x i16]** %2
%238 = getelementptr inbounds [5 x i16], [5 x i16]* %237, i64 3
%239 = getelementptr inbounds [5 x i16], [5 x i16]* %238, i64 0, i64 4
store i16 %236, i16* %239
ret void
}

LLVM IR (-O2):
define void @zero_4x5_col3([5 x i16]* nocapture %0) {
%2 = getelementptr inbounds [5 x i16], [5 x i16]* %0, i64 1, i64 3
%3 = load i16, i16* %2
%4 = getelementptr inbounds [5 x i16], [5 x i16]* %0, i64 0, i64 3
%5 = load i16, i16* %4
%6 = tail call zeroext i16 @gf4096_inv(i16 zeroext %5)
%7 = tail call zeroext i16 @gf4096_mul(i16 zeroext %3, i16 zeroext %6)
%8 = getelementptr inbounds [5 x i16], [5 x i16]* %0, i64 2, i64 3
%9 = load i16, i16* %8
%10 = load i16, i16* %4
%11 = tail call zeroext i16 @gf4096_inv(i16 zeroext %10)
%12 = tail call zeroext i16 @gf4096_mul(i16 zeroext %9, i16 zeroext %11)
%13 = getelementptr inbounds [5 x i16], [5 x i16]* %0, i64 3, i64 3
%14 = load i16, i16* %13
%15 = load i16, i16* %4
%16 = tail call zeroext i16 @gf4096_inv(i16 zeroext %15)
%17 = tail call zeroext i16 @gf4096_mul(i16 zeroext %14, i16 zeroext %16)
%18 = getelementptr inbounds [5 x i16], [5 x i16]* %0, i64 1, i64 0
%19 = load i16, i16* %18
%20 = getelementptr inbounds [5 x i16], [5 x i16]* %0, i64 0, i64 0
%21 = load i16, i16* %20
%22 = tail call zeroext i16 @gf4096_mul(i16 zeroext %21, i16 zeroext %7)
%23 = xor i16 %22, %19
store i16 %23, i16* %18
%24 = getelementptr inbounds [5 x i16], [5 x i16]* %0, i64 1, i64 1
%25 = load i16, i16* %24
%26 = getelementptr inbounds [5 x i16], [5 x i16]* %0, i64 0, i64 1
%27 = load i16, i16* %26
%28 = tail call zeroext i16 @gf4096_mul(i16 zeroext %27, i16 zeroext %7)
%29 = xor i16 %28, %25
store i16 %29, i16* %24
%30 = getelementptr inbounds [5 x i16], [5 x i16]* %0, i64 1, i64 2
%31 = load i16, i16* %30
%32 = getelementptr inbounds [5 x i16], [5 x i16]* %0, i64 0, i64 2
%33 = load i16, i16* %32
%34 = tail call zeroext i16 @gf4096_mul(i16 zeroext %33, i16 zeroext %7)
%35 = xor i16 %34, %31
store i16 %35, i16* %30
%36 = getelementptr inbounds [5 x i16], [5 x i16]* %0, i64 1, i64 4
%37 = load i16, i16* %36
%38 = getelementptr inbounds [5 x i16], [5 x i16]* %0, i64 0, i64 4
%39 = load i16, i16* %38
%40 = tail call zeroext i16 @gf4096_mul(i16 zeroext %39, i16 zeroext %7)
%41 = xor i16 %40, %37
store i16 %41, i16* %36
%42 = getelementptr inbounds [5 x i16], [5 x i16]* %0, i64 2, i64 0
%43 = load i16, i16* %42
%44 = load i16, i16* %20
%45 = tail call zeroext i16 @gf4096_mul(i16 zeroext %44, i16 zeroext %12)
%46 = xor i16 %45, %43
store i16 %46, i16* %42
%47 = getelementptr inbounds [5 x i16], [5 x i16]* %0, i64 2, i64 1
%48 = load i16, i16* %47
%49 = load i16, i16* %26
%50 = tail call zeroext i16 @gf4096_mul(i16 zeroext %49, i16 zeroext %12)
%51 = xor i16 %50, %48
store i16 %51, i16* %47
%52 = getelementptr inbounds [5 x i16], [5 x i16]* %0, i64 2, i64 2
%53 = load i16, i16* %52
%54 = load i16, i16* %32
%55 = tail call zeroext i16 @gf4096_mul(i16 zeroext %54, i16 zeroext %12)
%56 = xor i16 %55, %53
store i16 %56, i16* %52
%57 = getelementptr inbounds [5 x i16], [5 x i16]* %0, i64 2, i64 4
%58 = load i16, i16* %57
%59 = load i16, i16* %38
%60 = tail call zeroext i16 @gf4096_mul(i16 zeroext %59, i16 zeroext %12)
%61 = xor i16 %60, %58
store i16 %61, i16* %57
%62 = getelementptr inbounds [5 x i16], [5 x i16]* %0, i64 3, i64 0
%63 = load i16, i16* %62
%64 = load i16, i16* %20
%65 = tail call zeroext i16 @gf4096_mul(i16 zeroext %64, i16 zeroext %17)
%66 = xor i16 %65, %63
store i16 %66, i16* %62
%67 = getelementptr inbounds [5 x i16], [5 x i16]* %0, i64 3, i64 1
%68 = load i16, i16* %67
%69 = load i16, i16* %26
%70 = tail call zeroext i16 @gf4096_mul(i16 zeroext %69, i16 zeroext %17)
%71 = xor i16 %70, %68
store i16 %71, i16* %67
%72 = getelementptr inbounds [5 x i16], [5 x i16]* %0, i64 3, i64 2
%73 = load i16, i16* %72
%74 = load i16, i16* %32
%75 = tail call zeroext i16 @gf4096_mul(i16 zeroext %74, i16 zeroext %17)
%76 = xor i16 %75, %73
store i16 %76, i16* %72
%77 = getelementptr inbounds [5 x i16], [5 x i16]* %0, i64 3, i64 4
%78 = load i16, i16* %77
%79 = load i16, i16* %38
%80 = tail call zeroext i16 @gf4096_mul(i16 zeroext %79, i16 zeroext %17)
%81 = xor i16 %80, %78
store i16 %81, i16* %77
ret void
}