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

/* Variables and functions */
int *malloc(int);
uint32_t *initTriangleSeq(uint32_t max) {
  uint32_t *tmp = malloc(max * sizeof(uint32_t));
  for (uint32_t i = 1; i < max; i++) {
    tmp[i] = (i * (i + 1)) / 2;
  }
  return tmp;
}


x86 assembly (clang, -O0):
<initTriangleSeq>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %edi,-0x4(%rbp)
movslq -0x4(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x10(%rbp)
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1170 <initTriangleSeq+0x60>
mov    -0x14(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1135 <initTriangleSeq+0x25>
mov    -0x10(%rbp),%rax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<initTriangleSeq>:
push   %rbx
mov    %edi,%ebx
lea    0x0(,%rbx,4),%edi
call   1030 <malloc@plt>
cmp    $0x2,%ebx
jl     1246 <initTriangleSeq+0x136>
mov    %ebx,%ecx
lea    -0x1(%rcx),%rsi
mov    $0x1,%edx
cmp    $0x8,%rsi
jb     1230 <initTriangleSeq+0x120>
mov    %rsi,%rdi
and    $0xfffffffffffffff8,%rdi
lea    0x1(%rdi),%rdx
movaps 0xeb1(%rip),%xmm0
movaps 0xeba(%rip),%xmm4
movdqa 0xec2(%rip),%xmm3
xor    %ebx,%ebx
movdqa 0xec7(%rip),%xmm8
pcmpeqd %xmm9,%xmm9
movdqa 0xec9(%rip),%xmm10
movdqa 0xed0(%rip),%xmm12
movdqa 0xed7(%rip),%xmm11
nopl   0x0(%rax)
movdqa %xmm3,%xmm2
paddd  %xmm8,%xmm2
movaps %xmm4,%xmm1
shufps $0x88,%xmm0,%xmm1
movaps %xmm1,%xmm5
psubd  %xmm9,%xmm5
paddd  %xmm10,%xmm1
pshufd $0xf5,%xmm5,%xmm7
pmuludq %xmm3,%xmm5
pshufd $0xe8,%xmm5,%xmm5
pshufd $0xf5,%xmm3,%xmm6
pmuludq %xmm7,%xmm6
pshufd $0xe8,%xmm6,%xmm6
punpckldq %xmm6,%xmm5
pshufd $0xf5,%xmm1,%xmm6
pmuludq %xmm2,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pshufd $0xf5,%xmm2,%xmm2
pmuludq %xmm6,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm1
psrld  $0x1,%xmm5
psrld  $0x1,%xmm1
movdqu %xmm5,0x4(%rax,%rbx,4)
movdqu %xmm1,0x14(%rax,%rbx,4)
add    $0x8,%rbx
paddq  %xmm12,%xmm4
paddq  %xmm12,%xmm0
paddd  %xmm11,%xmm3
cmp    %rbx,%rdi
jne    1190 <initTriangleSeq+0x80>
cmp    %rdi,%rsi
je     1246 <initTriangleSeq+0x136>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x1(%rdx),%rsi
mov    %esi,%edi
imul   %edx,%edi
shr    %edi
mov    %edi,(%rax,%rdx,4)
mov    %rsi,%rdx
cmp    %rsi,%rcx
jne    1230 <initTriangleSeq+0x120>
pop    %rbx
ret

LLVM IR (-O0):
define i32* @initTriangleSeq(i32 %0) {
%2 = alloca i32
%3 = alloca i32*
%4 = alloca i32
store i32 %0, i32* %2
%5 = load i32, i32* %2
%6 = sext i32 %5 to i64
%7 = mul i64 %6, 4
%8 = trunc i64 %7 to i32
%9 = call i32* @malloc(i32 %8)
store i32* %9, i32** %3
store i32 1, i32* %4
br label %10
10: ; preds = %24, %1
%11 = load i32, i32* %4
%12 = load i32, i32* %2
%13 = icmp slt i32 %11, %12
br i1 %13, label %14, label %27
14: ; preds = %10
%15 = load i32, i32* %4
%16 = load i32, i32* %4
%17 = add nsw i32 %16, 1
%18 = mul nsw i32 %15, %17
%19 = sdiv i32 %18, 2
%20 = load i32*, i32** %3
%21 = load i32, i32* %4
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds i32, i32* %20, i64 %22
store i32 %19, i32* %23
br label %24
24: ; preds = %14
%25 = load i32, i32* %4
%26 = add nsw i32 %25, 1
store i32 %26, i32* %4
br label %10
27: ; preds = %10
%28 = load i32*, i32** %3
ret i32* %28
}

LLVM IR (-O2):
define noalias i32* @initTriangleSeq(i32 %0) {
%2 = shl i32 %0, 2
%3 = tail call i32* @malloc(i32 %2)
%4 = icmp sgt i32 %0, 1
br i1 %4, label %5, label %38
5: ; preds = %1
%6 = zext i32 %0 to i64
%7 = add nsw i64 %6, -1
%8 = icmp ult i64 %7, 8
br i1 %8, label %36, label %9
9: ; preds = %5
%10 = and i64 %7, -8
%11 = or i64 %10, 1
br label %12
12: ; preds = %12, %9
%13 = phi i64 [ 0, %9 ], [ %30, %12 ]
%14 = phi <4 x i64> [ <i64 1, i64 2, i64 3, i64 4>, %9 ], [ %31, %12 ]
%15 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %9 ], [ %32, %12 ]
%16 = or i64 %13, 1
%17 = add <4 x i32> %15, <i32 4, i32 4, i32 4, i32 4>
%18 = trunc <4 x i64> %14 to <4 x i32>
%19 = add <4 x i32> %18, <i32 1, i32 1, i32 1, i32 1>
%20 = trunc <4 x i64> %14 to <4 x i32>
%21 = add <4 x i32> %20, <i32 5, i32 5, i32 5, i32 5>
%22 = mul nsw <4 x i32> %19, %15
%23 = mul nsw <4 x i32> %21, %17
%24 = lshr <4 x i32> %22, <i32 1, i32 1, i32 1, i32 1>
%25 = lshr <4 x i32> %23, <i32 1, i32 1, i32 1, i32 1>
%26 = getelementptr inbounds i32, i32* %3, i64 %16
%27 = bitcast i32* %26 to <4 x i32>*
store <4 x i32> %24, <4 x i32>* %27
%28 = getelementptr inbounds i32, i32* %26, i64 4
%29 = bitcast i32* %28 to <4 x i32>*
store <4 x i32> %25, <4 x i32>* %29
%30 = add nuw i64 %13, 8
%31 = add <4 x i64> %14, <i64 8, i64 8, i64 8, i64 8>
%32 = add <4 x i32> %15, <i32 8, i32 8, i32 8, i32 8>
%33 = icmp eq i64 %30, %10
br i1 %33, label %34, label %12
34: ; preds = %12
%35 = icmp eq i64 %7, %10
br i1 %35, label %38, label %36
36: ; preds = %5, %34
%37 = phi i64 [ 1, %5 ], [ %11, %34 ]
br label %39
38: ; preds = %39, %34, %1
ret i32* %3
39: ; preds = %36, %39
%40 = phi i64 [ %41, %39 ], [ %37, %36 ]
%41 = add nuw nsw i64 %40, 1
%42 = trunc i64 %41 to i32
%43 = trunc i64 %40 to i32
%44 = mul nsw i32 %42, %43
%45 = lshr i32 %44, 1
%46 = getelementptr inbounds i32, i32* %3, i64 %40
store i32 %45, i32* %46
%47 = icmp eq i64 %41, %6
br i1 %47, label %38, label %39
}