#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 */
int /*<<< orphan*/ abort();
__attribute__((no)) int main1(short X) {
  unsigned char a[26];
  unsigned short b[26];
  unsigned int c[26];
  short myX = X;
  int i;
  for (i = 0; i < 26; i++) {
    a[i] = (unsigned char)X;
    b[i] = X;
    c[i] = (unsigned int)X;
    X++;
  }
  for (i = 0; i < 26; i++) {
    if (a[i] != (unsigned char)myX || b[i] != myX ||
        c[i] != (unsigned int)myX++)
      abort();
  }
  return 0;
}


x86 assembly (clang, -O0):
<main1>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
mov    %di,%ax
mov    %ax,-0x2(%rbp)
mov    -0x2(%rbp),%ax
mov    %ax,-0xd2(%rbp)
movl   $0x0,-0xd8(%rbp)
cmpl   $0x1a,-0xd8(%rbp)
jge    1197 <main1+0x87>
mov    -0x2(%rbp),%ax
mov    %al,%cl
movslq -0xd8(%rbp),%rax
mov    %cl,-0x20(%rbp,%rax,1)
mov    -0x2(%rbp),%cx
movslq -0xd8(%rbp),%rax
mov    %cx,-0x60(%rbp,%rax,2)
movswl -0x2(%rbp),%ecx
movslq -0xd8(%rbp),%rax
mov    %ecx,-0xd0(%rbp,%rax,4)
mov    -0x2(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x2(%rbp)
mov    -0xd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
jmp    1137 <main1+0x27>
movl   $0x0,-0xd8(%rbp)
cmpl   $0x1a,-0xd8(%rbp)
jge    1235 <main1+0x125>
movslq -0xd8(%rbp),%rax
movzbl -0x20(%rbp,%rax,1),%eax
mov    -0xd2(%rbp),%cx
movzbl %cl,%ecx
cmp    %ecx,%eax
jne    1215 <main1+0x105>
movslq -0xd8(%rbp),%rax
movzwl -0x60(%rbp,%rax,2),%eax
movswl -0xd2(%rbp),%ecx
cmp    %ecx,%eax
jne    1215 <main1+0x105>
movslq -0xd8(%rbp),%rax
mov    -0xd0(%rbp,%rax,4),%eax
mov    -0xd2(%rbp),%cx
mov    %cx,%dx
add    $0x1,%dx
mov    %dx,-0xd2(%rbp)
movswl %cx,%ecx
cmp    %ecx,%eax
je     121c <main1+0x10c>
mov    $0x0,%al
call   1030 <abort@plt>
jmp    1221 <main1+0x111>
mov    -0xd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
jmp    11a1 <main1+0x91>
xor    %eax,%eax
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main1>:
sub    $0xc8,%rsp
lea    0x18(%rdi),%eax
movd   %edi,%xmm1
pshuflw $0x0,%xmm1,%xmm0
movdqa 0xed5(%rip),%xmm2
paddw  %xmm0,%xmm2
punpcklbw %xmm1,%xmm1
pshuflw $0x0,%xmm1,%xmm1
movdqa 0xed0(%rip),%xmm3
paddb  %xmm1,%xmm3
movdqa 0xed4(%rip),%xmm4
paddb  %xmm1,%xmm4
punpckldq %xmm4,%xmm3
pshufd $0x50,%xmm1,%xmm4
paddb  0xecf(%rip),%xmm4
punpcklqdq %xmm3,%xmm4
movdqa %xmm4,(%rsp)
movdqa 0xece(%rip),%xmm3
paddw  %xmm0,%xmm3
punpcklwd %xmm2,%xmm4
punpcklqdq %xmm3,%xmm2
movdqa %xmm2,0x20(%rsp)
psrad  $0x10,%xmm4
movdqa %xmm4,0x60(%rsp)
punpcklwd %xmm3,%xmm2
psrad  $0x10,%xmm2
movdqa %xmm2,0x70(%rsp)
movdqa 0xeaa(%rip),%xmm2
paddw  %xmm0,%xmm2
movdqa 0xeae(%rip),%xmm3
paddw  %xmm0,%xmm3
punpcklwd %xmm2,%xmm4
punpcklqdq %xmm3,%xmm2
movdqa %xmm2,0x30(%rsp)
psrad  $0x10,%xmm4
movdqa %xmm4,0x80(%rsp)
punpcklwd %xmm3,%xmm2
psrad  $0x10,%xmm2
movdqa %xmm2,0x90(%rsp)
movdqa 0xe84(%rip),%xmm2
paddw  %xmm0,%xmm2
movdqa 0xe88(%rip),%xmm3
paddb  %xmm1,%xmm3
movd   %xmm3,0x10(%rsp)
paddw  0xe86(%rip),%xmm0
punpcklwd %xmm2,%xmm3
punpcklqdq %xmm0,%xmm2
movdqa %xmm2,0x40(%rsp)
psrad  $0x10,%xmm3
paddb  0xe7b(%rip),%xmm1
movdqa %xmm3,0xa0(%rsp)
movd   %xmm1,0x14(%rsp)
punpcklwd %xmm0,%xmm0
psrad  $0x10,%xmm0
movdqa %xmm0,0xb0(%rsp)
mov    %al,0x18(%rsp)
mov    %ax,0x50(%rsp)
cwtl
mov    %eax,0xc0(%rsp)
lea    0x19(%rdi),%eax
mov    %al,0x19(%rsp)
mov    %ax,0x52(%rsp)
cwtl
mov    %eax,0xc4(%rsp)
movzwl %di,%eax
xor    %ecx,%ecx
lea    (%rax,%rcx,1),%rdx
cmp    (%rsp,%rcx,1),%dl
jne    12c5 <main1+0x1b5>
movzwl 0x20(%rsp,%rcx,2),%esi
movswl %dx,%edx
cmp    %edx,%esi
jne    12c5 <main1+0x1b5>
cmp    %esi,0x60(%rsp,%rcx,4)
jne    12c5 <main1+0x1b5>
lea    0x1(%rdi),%edx
cmp    %dl,0x1(%rsp,%rcx,1)
jne    12c5 <main1+0x1b5>
lea    (%rax,%rcx,1),%rsi
add    $0x1,%rsi
movzwl 0x22(%rsp,%rcx,2),%edx
movswl %si,%esi
cmp    %esi,%edx
jne    12c5 <main1+0x1b5>
cmp    %edx,0x64(%rsp,%rcx,4)
jne    12c5 <main1+0x1b5>
add    $0x2,%edi
add    $0x2,%rcx
cmp    $0x1a,%rcx
jne    1270 <main1+0x160>
xor    %eax,%eax
add    $0xc8,%rsp
ret
xor    %eax,%eax
call   1030 <abort@plt>

LLVM IR (-O0):
define i32 @main1(i16 signext %0) {
%2 = alloca i16
%3 = alloca [26 x i8]
%4 = alloca [26 x i16]
%5 = alloca [26 x i32]
%6 = alloca i16
%7 = alloca i32
store i16 %0, i16* %2
%8 = load i16, i16* %2
store i16 %8, i16* %6
store i32 0, i32* %7
br label %9
9: ; preds = %29, %1
%10 = load i32, i32* %7
%11 = icmp slt i32 %10, 26
br i1 %11, label %12, label %32
12: ; preds = %9
%13 = load i16, i16* %2
%14 = trunc i16 %13 to i8
%15 = load i32, i32* %7
%16 = sext i32 %15 to i64
%17 = getelementptr inbounds [26 x i8], [26 x i8]* %3, i64 0, i64 %16
store i8 %14, i8* %17
%18 = load i16, i16* %2
%19 = load i32, i32* %7
%20 = sext i32 %19 to i64
%21 = getelementptr inbounds [26 x i16], [26 x i16]* %4, i64 0, i64 %20
store i16 %18, i16* %21
%22 = load i16, i16* %2
%23 = sext i16 %22 to i32
%24 = load i32, i32* %7
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds [26 x i32], [26 x i32]* %5, i64 0, i64 %25
store i32 %23, i32* %26
%27 = load i16, i16* %2
%28 = add i16 %27, 1
store i16 %28, i16* %2
br label %29
29: ; preds = %12
%30 = load i32, i32* %7
%31 = add nsw i32 %30, 1
store i32 %31, i32* %7
br label %9
32: ; preds = %9
store i32 0, i32* %7
br label %33
33: ; preds = %67, %32
%34 = load i32, i32* %7
%35 = icmp slt i32 %34, 26
br i1 %35, label %36, label %70
36: ; preds = %33
%37 = load i32, i32* %7
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds [26 x i8], [26 x i8]* %3, i64 0, i64 %38
%40 = load i8, i8* %39
%41 = zext i8 %40 to i32
%42 = load i16, i16* %6
%43 = trunc i16 %42 to i8
%44 = zext i8 %43 to i32
%45 = icmp ne i32 %41, %44
br i1 %45, label %64, label %46
46: ; preds = %36
%47 = load i32, i32* %7
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds [26 x i16], [26 x i16]* %4, i64 0, i64 %48
%50 = load i16, i16* %49
%51 = zext i16 %50 to i32
%52 = load i16, i16* %6
%53 = sext i16 %52 to i32
%54 = icmp ne i32 %51, %53
br i1 %54, label %64, label %55
55: ; preds = %46
%56 = load i32, i32* %7
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds [26 x i32], [26 x i32]* %5, i64 0, i64 %57
%59 = load i32, i32* %58
%60 = load i16, i16* %6
%61 = add i16 %60, 1
store i16 %61, i16* %6
%62 = sext i16 %60 to i32
%63 = icmp ne i32 %59, %62
br i1 %63, label %64, label %66
64: ; preds = %55, %46, %36
%65 = call i32 (...) @abort()
unreachable
66: ; preds = %55
br label %67
67: ; preds = %66
%68 = load i32, i32* %7
%69 = add nsw i32 %68, 1
store i32 %69, i32* %7
br label %33
70: ; preds = %33
ret i32 0
}

LLVM IR (-O2):
define i32 @main1(i16 signext %0) {
%2 = alloca [26 x i8]
%3 = alloca [26 x i16]
%4 = alloca [26 x i32]
%5 = getelementptr inbounds [26 x i8], [26 x i8]* %2, i64 0, i64 0
%6 = bitcast [26 x i16]* %3 to i8*
%7 = bitcast [26 x i32]* %4 to i8*
%8 = add i16 %0, 24
%9 = insertelement <4 x i16> poison, i16 %0, i64 0
%10 = shufflevector <4 x i16> %9, <4 x i16> poison, <4 x i32> zeroinitializer
%11 = add <4 x i16> %10, <i16 0, i16 1, i16 2, i16 3>
%12 = trunc i16 %0 to i8
%13 = insertelement <4 x i8> poison, i8 %12, i64 0
%14 = shufflevector <4 x i8> %13, <4 x i8> poison, <4 x i32> zeroinitializer
%15 = add <4 x i8> %14, <i8 0, i8 1, i8 2, i8 3>
%16 = bitcast [26 x i8]* %2 to <4 x i8>*
store <4 x i8> %15, <4 x i8>* %16
%17 = bitcast [26 x i16]* %3 to <4 x i16>*
store <4 x i16> %11, <4 x i16>* %17
%18 = sext <4 x i16> %11 to <4 x i32>
%19 = bitcast [26 x i32]* %4 to <4 x i32>*
store <4 x i32> %18, <4 x i32>* %19
%20 = add <4 x i16> %10, <i16 4, i16 5, i16 6, i16 7>
%21 = add <4 x i8> %14, <i8 4, i8 5, i8 6, i8 7>
%22 = getelementptr inbounds [26 x i8], [26 x i8]* %2, i64 0, i64 4
%23 = bitcast i8* %22 to <4 x i8>*
store <4 x i8> %21, <4 x i8>* %23
%24 = getelementptr inbounds [26 x i16], [26 x i16]* %3, i64 0, i64 4
%25 = bitcast i16* %24 to <4 x i16>*
store <4 x i16> %20, <4 x i16>* %25
%26 = sext <4 x i16> %20 to <4 x i32>
%27 = getelementptr inbounds [26 x i32], [26 x i32]* %4, i64 0, i64 4
%28 = bitcast i32* %27 to <4 x i32>*
store <4 x i32> %26, <4 x i32>* %28
%29 = add <4 x i16> %10, <i16 8, i16 9, i16 10, i16 11>
%30 = add <4 x i8> %14, <i8 8, i8 9, i8 10, i8 11>
%31 = getelementptr inbounds [26 x i8], [26 x i8]* %2, i64 0, i64 8
%32 = bitcast i8* %31 to <4 x i8>*
store <4 x i8> %30, <4 x i8>* %32
%33 = getelementptr inbounds [26 x i16], [26 x i16]* %3, i64 0, i64 8
%34 = bitcast i16* %33 to <4 x i16>*
store <4 x i16> %29, <4 x i16>* %34
%35 = sext <4 x i16> %29 to <4 x i32>
%36 = getelementptr inbounds [26 x i32], [26 x i32]* %4, i64 0, i64 8
%37 = bitcast i32* %36 to <4 x i32>*
store <4 x i32> %35, <4 x i32>* %37
%38 = add <4 x i16> %10, <i16 12, i16 13, i16 14, i16 15>
%39 = add <4 x i8> %14, <i8 12, i8 13, i8 14, i8 15>
%40 = getelementptr inbounds [26 x i8], [26 x i8]* %2, i64 0, i64 12
%41 = bitcast i8* %40 to <4 x i8>*
store <4 x i8> %39, <4 x i8>* %41
%42 = getelementptr inbounds [26 x i16], [26 x i16]* %3, i64 0, i64 12
%43 = bitcast i16* %42 to <4 x i16>*
store <4 x i16> %38, <4 x i16>* %43
%44 = sext <4 x i16> %38 to <4 x i32>
%45 = getelementptr inbounds [26 x i32], [26 x i32]* %4, i64 0, i64 12
%46 = bitcast i32* %45 to <4 x i32>*
store <4 x i32> %44, <4 x i32>* %46
%47 = add <4 x i16> %10, <i16 16, i16 17, i16 18, i16 19>
%48 = add <4 x i8> %14, <i8 16, i8 17, i8 18, i8 19>
%49 = getelementptr inbounds [26 x i8], [26 x i8]* %2, i64 0, i64 16
%50 = bitcast i8* %49 to <4 x i8>*
store <4 x i8> %48, <4 x i8>* %50
%51 = getelementptr inbounds [26 x i16], [26 x i16]* %3, i64 0, i64 16
%52 = bitcast i16* %51 to <4 x i16>*
store <4 x i16> %47, <4 x i16>* %52
%53 = sext <4 x i16> %47 to <4 x i32>
%54 = getelementptr inbounds [26 x i32], [26 x i32]* %4, i64 0, i64 16
%55 = bitcast i32* %54 to <4 x i32>*
store <4 x i32> %53, <4 x i32>* %55
%56 = add <4 x i16> %10, <i16 20, i16 21, i16 22, i16 23>
%57 = add <4 x i8> %14, <i8 20, i8 21, i8 22, i8 23>
%58 = getelementptr inbounds [26 x i8], [26 x i8]* %2, i64 0, i64 20
%59 = bitcast i8* %58 to <4 x i8>*
store <4 x i8> %57, <4 x i8>* %59
%60 = getelementptr inbounds [26 x i16], [26 x i16]* %3, i64 0, i64 20
%61 = bitcast i16* %60 to <4 x i16>*
store <4 x i16> %56, <4 x i16>* %61
%62 = sext <4 x i16> %56 to <4 x i32>
%63 = getelementptr inbounds [26 x i32], [26 x i32]* %4, i64 0, i64 20
%64 = bitcast i32* %63 to <4 x i32>*
store <4 x i32> %62, <4 x i32>* %64
%65 = trunc i16 %8 to i8
%66 = getelementptr inbounds [26 x i8], [26 x i8]* %2, i64 0, i64 24
store i8 %65, i8* %66
%67 = getelementptr inbounds [26 x i16], [26 x i16]* %3, i64 0, i64 24
store i16 %8, i16* %67
%68 = sext i16 %8 to i32
%69 = getelementptr inbounds [26 x i32], [26 x i32]* %4, i64 0, i64 24
store i32 %68, i32* %69
%70 = add i16 %0, 25
%71 = trunc i16 %70 to i8
%72 = getelementptr inbounds [26 x i8], [26 x i8]* %2, i64 0, i64 25
store i8 %71, i8* %72
%73 = getelementptr inbounds [26 x i16], [26 x i16]* %3, i64 0, i64 25
store i16 %70, i16* %73
%74 = sext i16 %70 to i32
%75 = getelementptr inbounds [26 x i32], [26 x i32]* %4, i64 0, i64 25
store i32 %74, i32* %75
br label %76
76: ; preds = %112, %1
%77 = phi i64 [ 0, %1 ], [ %114, %112 ]
%78 = phi i16 [ %0, %1 ], [ %113, %112 ]
%79 = getelementptr inbounds [26 x i8], [26 x i8]* %2, i64 0, i64 %77
%80 = load i8, i8* %79
%81 = trunc i16 %78 to i8
%82 = icmp eq i8 %80, %81
br i1 %82, label %83, label %93
83: ; preds = %76
%84 = getelementptr inbounds [26 x i16], [26 x i16]* %3, i64 0, i64 %77
%85 = load i16, i16* %84
%86 = zext i16 %85 to i32
%87 = sext i16 %78 to i32
%88 = icmp eq i32 %86, %87
br i1 %88, label %89, label %93
89: ; preds = %83
%90 = getelementptr inbounds [26 x i32], [26 x i32]* %4, i64 0, i64 %77
%91 = load i32, i32* %90
%92 = icmp eq i32 %91, %86
br i1 %92, label %95, label %93
93: ; preds = %108, %102, %95, %89, %83, %76
%94 = tail call i32 (...) @abort()
unreachable
95: ; preds = %89
%96 = add i16 %78, 1
%97 = or i64 %77, 1
%98 = getelementptr inbounds [26 x i8], [26 x i8]* %2, i64 0, i64 %97
%99 = load i8, i8* %98
%100 = trunc i16 %96 to i8
%101 = icmp eq i8 %99, %100
br i1 %101, label %102, label %93
102: ; preds = %95
%103 = getelementptr inbounds [26 x i16], [26 x i16]* %3, i64 0, i64 %97
%104 = load i16, i16* %103
%105 = zext i16 %104 to i32
%106 = sext i16 %96 to i32
%107 = icmp eq i32 %105, %106
br i1 %107, label %108, label %93
108: ; preds = %102
%109 = getelementptr inbounds [26 x i32], [26 x i32]* %4, i64 0, i64 %97
%110 = load i32, i32* %109
%111 = icmp eq i32 %110, %105
br i1 %111, label %112, label %93
112: ; preds = %108
%113 = add i16 %78, 2
%114 = add nuw nsw i64 %77, 2
%115 = icmp eq i64 %114, 26
br i1 %115, label %116, label %76
116: ; preds = %112
ret i32 0
}