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

/* Variables and functions */
void add(int ticks, int32_t *x, int32_t *y, int scalar, int32_t *s) {
  for (int i = 0; i < ticks; i++)
    s[i] = x[i] + y[i] + scalar;
}


x86 assembly (clang, -O0):
<add>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1162 <add+0x62>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
add    (%rax,%rcx,8),%rdx
movslq -0x1c(%rbp),%rax
add    %rax,%rdx
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    111d <add+0x1d>
pop    %rbp
ret

x86 assembly (clang, -O2):
<add>:
push   %rbx
test   %edi,%edi
jle    1295 <add+0x195>
movslq %ecx,%r11
mov    %edi,%r9d
cmp    $0x4,%edi
jae    116f <add+0x6f>
xor    %edi,%edi
mov    %rdi,%rax
not    %rax
test   $0x1,%r9b
je     1135 <add+0x35>
mov    (%rsi,%rdi,8),%rcx
add    %r11,%rcx
add    (%rdx,%rdi,8),%rcx
mov    %rcx,(%r8,%rdi,8)
or     $0x1,%rdi
add    %r9,%rax
je     1295 <add+0x195>
xchg   %ax,%ax
mov    (%rsi,%rdi,8),%rax
add    %r11,%rax
add    (%rdx,%rdi,8),%rax
mov    %rax,(%r8,%rdi,8)
mov    0x8(%rsi,%rdi,8),%rax
add    %r11,%rax
add    0x8(%rdx,%rdi,8),%rax
mov    %rax,0x8(%r8,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r9
jne    1140 <add+0x40>
jmp    1295 <add+0x195>
lea    (%r8,%r9,8),%rcx
lea    (%rsi,%r9,8),%rax
cmp    %r8,%rax
seta   %r10b
lea    (%rdx,%r9,8),%rax
cmp    %rsi,%rcx
seta   %bl
cmp    %r8,%rax
seta   %al
cmp    %rdx,%rcx
seta   %cl
xor    %edi,%edi
test   %bl,%r10b
jne    1116 <add+0x16>
and    %cl,%al
jne    1116 <add+0x16>
mov    %r9d,%edi
and    $0xfffffffc,%edi
movq   %r11,%xmm0
pshufd $0x44,%xmm0,%xmm0
lea    -0x4(%rdi),%rax
mov    %rax,%r10
shr    $0x2,%r10
add    $0x1,%r10
test   %rax,%rax
je     1297 <add+0x197>
mov    %r10,%rax
and    $0xfffffffffffffffe,%rax
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movdqu (%rsi,%rcx,8),%xmm1
movdqu 0x10(%rsi,%rcx,8),%xmm2
movdqu (%rdx,%rcx,8),%xmm3
movdqu 0x10(%rdx,%rcx,8),%xmm4
paddq  %xmm0,%xmm1
paddq  %xmm3,%xmm1
paddq  %xmm0,%xmm2
paddq  %xmm4,%xmm2
movdqu %xmm1,(%r8,%rcx,8)
movdqu %xmm2,0x10(%r8,%rcx,8)
movdqu 0x20(%rsi,%rcx,8),%xmm1
movdqu 0x30(%rsi,%rcx,8),%xmm2
movdqu 0x20(%rdx,%rcx,8),%xmm3
movdqu 0x30(%rdx,%rcx,8),%xmm4
paddq  %xmm0,%xmm1
paddq  %xmm3,%xmm1
paddq  %xmm0,%xmm2
paddq  %xmm4,%xmm2
movdqu %xmm1,0x20(%r8,%rcx,8)
movdqu %xmm2,0x30(%r8,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rax
jne    11e0 <add+0xe0>
test   $0x1,%r10b
je     128c <add+0x18c>
movdqu (%rsi,%rcx,8),%xmm1
movdqu 0x10(%rsi,%rcx,8),%xmm2
movdqu (%rdx,%rcx,8),%xmm3
movdqu 0x10(%rdx,%rcx,8),%xmm4
paddq  %xmm0,%xmm1
paddq  %xmm3,%xmm1
paddq  %xmm0,%xmm2
paddq  %xmm4,%xmm2
movdqu %xmm1,(%r8,%rcx,8)
movdqu %xmm2,0x10(%r8,%rcx,8)
cmp    %r9,%rdi
jne    1116 <add+0x16>
pop    %rbx
ret
xor    %ecx,%ecx
test   $0x1,%r10b
jne    1259 <add+0x159>
jmp    128c <add+0x18c>

LLVM IR (-O0):
define void @add(i32 %0, i64* %1, i64* %2, i32 %3, i64* %4) {
%6 = alloca i32
%7 = alloca i64*
%8 = alloca i64*
%9 = alloca i32
%10 = alloca i64*
%11 = alloca i32
store i32 %0, i32* %6
store i64* %1, i64** %7
store i64* %2, i64** %8
store i32 %3, i32* %9
store i64* %4, i64** %10
store i32 0, i32* %11
br label %12
12: ; preds = %35, %5
%13 = load i32, i32* %11
%14 = load i32, i32* %6
%15 = icmp slt i32 %13, %14
br i1 %15, label %16, label %38
16: ; preds = %12
%17 = load i64*, i64** %7
%18 = load i32, i32* %11
%19 = sext i32 %18 to i64
%20 = getelementptr inbounds i64, i64* %17, i64 %19
%21 = load i64, i64* %20
%22 = load i64*, i64** %8
%23 = load i32, i32* %11
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds i64, i64* %22, i64 %24
%26 = load i64, i64* %25
%27 = add nsw i64 %21, %26
%28 = load i32, i32* %9
%29 = sext i32 %28 to i64
%30 = add nsw i64 %27, %29
%31 = load i64*, i64** %10
%32 = load i32, i32* %11
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds i64, i64* %31, i64 %33
store i64 %30, i64* %34
br label %35
35: ; preds = %16
%36 = load i32, i32* %11
%37 = add nsw i32 %36, 1
store i32 %37, i32* %11
br label %12
38: ; preds = %12
ret void
}

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