#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;

/* Variables and functions */
void mc(uint8_t *arr) {
  for (int i = 0; i < 4; i++) {
    uint8_t a[4];
    uint8_t b[4];
    uint8_t c;
    uint8_t h;
    for (c = 0; c < 4; c++) {
      a[c] = arr[(4 * c + i)];
      h = (uint8_t)((signed char)arr[(4 * c + i)] >> 7);
      b[c] = arr[(4 * c + i)] << 1;
      b[c] ^= 0x1B & h;
    }
    arr[(i)] = b[0] ^ a[3] ^ a[2] ^ b[1] ^ a[1];
    arr[(4 + i)] = b[1] ^ a[0] ^ a[3] ^ b[2] ^ a[2];
    arr[(8 + i)] = b[2] ^ a[1] ^ a[0] ^ b[3] ^ a[3];
    arr[(12 + i)] = b[3] ^ a[2] ^ a[1] ^ b[0] ^ a[0];
  }
}


x86 assembly (clang, -O0):
<mc>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x4,-0xc(%rbp)
jge    1224 <mc+0x124>
movl   $0x0,-0x34(%rbp)
cmpl   $0x4,-0x34(%rbp)
jge    119f <mc+0x9f>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
shl    $0x2,%ecx
add    -0xc(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
movslq -0x34(%rbp),%rax
mov    %ecx,-0x20(%rbp,%rax,4)
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
shl    $0x2,%ecx
add    -0xc(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
movsbl %al,%eax
sar    $0x7,%eax
mov    %eax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
shl    $0x2,%ecx
add    -0xc(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
shl    $0x1,%ecx
movslq -0x34(%rbp),%rax
mov    %ecx,-0x30(%rbp,%rax,4)
mov    -0x38(%rbp),%ecx
and    $0x1b,%ecx
movslq -0x34(%rbp),%rax
xor    -0x30(%rbp,%rax,4),%ecx
mov    %ecx,-0x30(%rbp,%rax,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1120 <mc+0x20>
mov    -0x30(%rbp),%edx
xor    -0x14(%rbp),%edx
xor    -0x18(%rbp),%edx
xor    -0x2c(%rbp),%edx
xor    -0x1c(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%edx
xor    -0x20(%rbp),%edx
xor    -0x14(%rbp),%edx
xor    -0x28(%rbp),%edx
xor    -0x18(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%edx
xor    -0x1c(%rbp),%edx
xor    -0x20(%rbp),%edx
xor    -0x24(%rbp),%edx
xor    -0x14(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%edx
xor    -0x18(%rbp),%edx
xor    -0x1c(%rbp),%edx
xor    -0x30(%rbp),%edx
xor    -0x20(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0xc,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    110f <mc+0xf>
pop    %rbp
ret

x86 assembly (clang, -O2):
<mc>:
movdqu (%rdi),%xmm4
movdqu 0x10(%rdi),%xmm10
movdqu 0x20(%rdi),%xmm6
movdqu 0x30(%rdi),%xmm1
movdqa %xmm4,%xmm3
movdqa %xmm6,%xmm8
movdqa %xmm6,%xmm5
movdqa %xmm1,%xmm9
movdqa %xmm1,%xmm7
movdqa %xmm6,%xmm0
pxor   %xmm1,%xmm0
movdqa %xmm0,%xmm11
pxor   %xmm4,%xmm0
pxor   %xmm10,%xmm1
pxor   %xmm4,%xmm1
pxor   %xmm10,%xmm6
pxor   %xmm4,%xmm6
paddd  %xmm4,%xmm4
pslld  $0x18,%xmm3
psrad  $0x1f,%xmm3
movdqa 0xe9c(%rip),%xmm12
pand   %xmm12,%xmm3
pxor   %xmm4,%xmm3
movdqa %xmm10,%xmm4
paddd  %xmm10,%xmm4
movdqa %xmm10,%xmm2
pslld  $0x18,%xmm2
psrad  $0x1f,%xmm2
pand   %xmm12,%xmm2
pxor   %xmm4,%xmm2
paddd  %xmm8,%xmm8
pslld  $0x18,%xmm5
psrad  $0x1f,%xmm5
pand   %xmm12,%xmm5
pxor   %xmm8,%xmm5
paddd  %xmm9,%xmm9
pslld  $0x18,%xmm7
psrad  $0x1f,%xmm7
pand   %xmm12,%xmm7
pxor   %xmm9,%xmm7
pxor   %xmm3,%xmm11
pxor   %xmm2,%xmm0
pxor   %xmm10,%xmm2
pxor   %xmm11,%xmm2
movdqu %xmm2,(%rdi)
pxor   %xmm5,%xmm0
movdqu %xmm0,0x10(%rdi)
pxor   %xmm5,%xmm1
pxor   %xmm7,%xmm1
movdqu %xmm1,0x20(%rdi)
pxor   %xmm3,%xmm6
pxor   %xmm7,%xmm6
movdqu %xmm6,0x30(%rdi)
ret

LLVM IR (-O0):
define void @mc(i32* %0) {
%2 = alloca i32*
%3 = alloca i32
%4 = alloca [4 x i32]
%5 = alloca [4 x i32]
%6 = alloca i32
%7 = alloca i32
store i32* %0, i32** %2
store i32 0, i32* %3
br label %8
8: ; preds = %136, %1
%9 = load i32, i32* %3
%10 = icmp slt i32 %9, 4
br i1 %10, label %11, label %139
11: ; preds = %8
store i32 0, i32* %6
br label %12
12: ; preds = %57, %11
%13 = load i32, i32* %6
%14 = icmp slt i32 %13, 4
br i1 %14, label %15, label %60
15: ; preds = %12
%16 = load i32*, i32** %2
%17 = load i32, i32* %6
%18 = mul nsw i32 4, %17
%19 = load i32, i32* %3
%20 = add nsw i32 %18, %19
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds i32, i32* %16, i64 %21
%23 = load i32, i32* %22
%24 = load i32, i32* %6
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 %25
store i32 %23, i32* %26
%27 = load i32*, i32** %2
%28 = load i32, i32* %6
%29 = mul nsw i32 4, %28
%30 = load i32, i32* %3
%31 = add nsw i32 %29, %30
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds i32, i32* %27, i64 %32
%34 = load i32, i32* %33
%35 = trunc i32 %34 to i8
%36 = sext i8 %35 to i32
%37 = ashr i32 %36, 7
store i32 %37, i32* %7
%38 = load i32*, i32** %2
%39 = load i32, i32* %6
%40 = mul nsw i32 4, %39
%41 = load i32, i32* %3
%42 = add nsw i32 %40, %41
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds i32, i32* %38, i64 %43
%45 = load i32, i32* %44
%46 = shl i32 %45, 1
%47 = load i32, i32* %6
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds [4 x i32], [4 x i32]* %5, i64 0, i64 %48
store i32 %46, i32* %49
%50 = load i32, i32* %7
%51 = and i32 27, %50
%52 = load i32, i32* %6
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds [4 x i32], [4 x i32]* %5, i64 0, i64 %53
%55 = load i32, i32* %54
%56 = xor i32 %55, %51
store i32 %56, i32* %54
br label %57
57: ; preds = %15
%58 = load i32, i32* %6
%59 = add nsw i32 %58, 1
store i32 %59, i32* %6
br label %12
60: ; preds = %12
%61 = getelementptr inbounds [4 x i32], [4 x i32]* %5, i64 0, i64 0
%62 = load i32, i32* %61
%63 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 3
%64 = load i32, i32* %63
%65 = xor i32 %62, %64
%66 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 2
%67 = load i32, i32* %66
%68 = xor i32 %65, %67
%69 = getelementptr inbounds [4 x i32], [4 x i32]* %5, i64 0, i64 1
%70 = load i32, i32* %69
%71 = xor i32 %68, %70
%72 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 1
%73 = load i32, i32* %72
%74 = xor i32 %71, %73
%75 = load i32*, i32** %2
%76 = load i32, i32* %3
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds i32, i32* %75, i64 %77
store i32 %74, i32* %78
%79 = getelementptr inbounds [4 x i32], [4 x i32]* %5, i64 0, i64 1
%80 = load i32, i32* %79
%81 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 0
%82 = load i32, i32* %81
%83 = xor i32 %80, %82
%84 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 3
%85 = load i32, i32* %84
%86 = xor i32 %83, %85
%87 = getelementptr inbounds [4 x i32], [4 x i32]* %5, i64 0, i64 2
%88 = load i32, i32* %87
%89 = xor i32 %86, %88
%90 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 2
%91 = load i32, i32* %90
%92 = xor i32 %89, %91
%93 = load i32*, i32** %2
%94 = load i32, i32* %3
%95 = add nsw i32 4, %94
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds i32, i32* %93, i64 %96
store i32 %92, i32* %97
%98 = getelementptr inbounds [4 x i32], [4 x i32]* %5, i64 0, i64 2
%99 = load i32, i32* %98
%100 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 1
%101 = load i32, i32* %100
%102 = xor i32 %99, %101
%103 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 0
%104 = load i32, i32* %103
%105 = xor i32 %102, %104
%106 = getelementptr inbounds [4 x i32], [4 x i32]* %5, i64 0, i64 3
%107 = load i32, i32* %106
%108 = xor i32 %105, %107
%109 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 3
%110 = load i32, i32* %109
%111 = xor i32 %108, %110
%112 = load i32*, i32** %2
%113 = load i32, i32* %3
%114 = add nsw i32 8, %113
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds i32, i32* %112, i64 %115
store i32 %111, i32* %116
%117 = getelementptr inbounds [4 x i32], [4 x i32]* %5, i64 0, i64 3
%118 = load i32, i32* %117
%119 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 2
%120 = load i32, i32* %119
%121 = xor i32 %118, %120
%122 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 1
%123 = load i32, i32* %122
%124 = xor i32 %121, %123
%125 = getelementptr inbounds [4 x i32], [4 x i32]* %5, i64 0, i64 0
%126 = load i32, i32* %125
%127 = xor i32 %124, %126
%128 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 0
%129 = load i32, i32* %128
%130 = xor i32 %127, %129
%131 = load i32*, i32** %2
%132 = load i32, i32* %3
%133 = add nsw i32 12, %132
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds i32, i32* %131, i64 %134
store i32 %130, i32* %135
br label %136
136: ; preds = %60
%137 = load i32, i32* %3
%138 = add nsw i32 %137, 1
store i32 %138, i32* %3
br label %8
139: ; preds = %8
ret void
}

LLVM IR (-O2):
define void @mc(i32* nocapture %0) {
%2 = getelementptr i32, i32* %0, i64 8
%3 = bitcast i32* %2 to <4 x i32>*
%4 = load <4 x i32>, <4 x i32>* %3
%5 = bitcast i32* %0 to <4 x i32>*
%6 = load <4 x i32>, <4 x i32>* %5
%7 = shl <4 x i32> %6, <i32 1, i32 1, i32 1, i32 1>
%8 = and <4 x i32> %6, <i32 128, i32 128, i32 128, i32 128>
%9 = icmp eq <4 x i32> %8, zeroinitializer
%10 = select <4 x i1> %9, <4 x i32> zeroinitializer, <4 x i32> <i32 27, i32 27, i32 27, i32 27>
%11 = xor <4 x i32> %10, %7
%12 = getelementptr inbounds i32, i32* %0, i64 4
%13 = bitcast i32* %12 to <4 x i32>*
%14 = load <4 x i32>, <4 x i32>* %13
%15 = shl <4 x i32> %14, <i32 1, i32 1, i32 1, i32 1>
%16 = and <4 x i32> %14, <i32 128, i32 128, i32 128, i32 128>
%17 = icmp eq <4 x i32> %16, zeroinitializer
%18 = select <4 x i1> %17, <4 x i32> zeroinitializer, <4 x i32> <i32 27, i32 27, i32 27, i32 27>
%19 = xor <4 x i32> %18, %15
%20 = getelementptr inbounds i32, i32* %0, i64 8
%21 = shl <4 x i32> %4, <i32 1, i32 1, i32 1, i32 1>
%22 = and <4 x i32> %4, <i32 128, i32 128, i32 128, i32 128>
%23 = icmp eq <4 x i32> %22, zeroinitializer
%24 = select <4 x i1> %23, <4 x i32> zeroinitializer, <4 x i32> <i32 27, i32 27, i32 27, i32 27>
%25 = xor <4 x i32> %24, %21
%26 = getelementptr inbounds i32, i32* %0, i64 12
%27 = bitcast i32* %26 to <4 x i32>*
%28 = load <4 x i32>, <4 x i32>* %27
%29 = shl <4 x i32> %28, <i32 1, i32 1, i32 1, i32 1>
%30 = and <4 x i32> %28, <i32 128, i32 128, i32 128, i32 128>
%31 = icmp eq <4 x i32> %30, zeroinitializer
%32 = select <4 x i1> %31, <4 x i32> zeroinitializer, <4 x i32> <i32 27, i32 27, i32 27, i32 27>
%33 = xor <4 x i32> %32, %29
%34 = xor <4 x i32> %4, %28
%35 = xor <4 x i32> %34, %11
%36 = xor <4 x i32> %35, %19
%37 = xor <4 x i32> %36, %14
%38 = bitcast i32* %0 to <4 x i32>*
store <4 x i32> %37, <4 x i32>* %38
%39 = xor <4 x i32> %34, %19
%40 = xor <4 x i32> %39, %6
%41 = xor <4 x i32> %40, %25
%42 = bitcast i32* %12 to <4 x i32>*
store <4 x i32> %41, <4 x i32>* %42
%43 = xor <4 x i32> %14, %28
%44 = xor <4 x i32> %43, %6
%45 = xor <4 x i32> %44, %25
%46 = xor <4 x i32> %45, %33
%47 = bitcast i32* %20 to <4 x i32>*
store <4 x i32> %46, <4 x i32>* %47
%48 = xor <4 x i32> %4, %11
%49 = xor <4 x i32> %48, %14
%50 = xor <4 x i32> %49, %6
%51 = xor <4 x i32> %50, %33
%52 = bitcast i32* %26 to <4 x i32>*
store <4 x i32> %51, <4 x i32>* %52
ret void
}