#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 *malloc(int);
int *ft_range(int min, int max) {
  int array_len;
  int i;
  int nb;
  int *range;
  if (min >= max)
    return (NULL);
  i = 0;
  nb = min;
  array_len = max - min;
  if (array_len < 0)
    return (NULL);
  range = malloc(array_len * sizeof(int));
  if (range == NULL)
    return (NULL);
  while (i < array_len)
    range[i++] = nb++;
  return (range);
}


x86 assembly (clang, -O0):
<ft_range>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %edi,-0xc(%rbp)
mov    %esi,-0x10(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jl     1137 <ft_range+0x27>
movq   $0x0,-0x8(%rbp)
jmp    11cd <ft_range+0xbd>
movl   $0x0,-0x18(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%eax
sub    -0xc(%rbp),%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
jge    1164 <ft_range+0x54>
movq   $0x0,-0x8(%rbp)
jmp    11cd <ft_range+0xbd>
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jne    118f <ft_range+0x7f>
movq   $0x0,-0x8(%rbp)
jmp    11cd <ft_range+0xbd>
jmp    1194 <ft_range+0x84>
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11c5 <ft_range+0xb5>
mov    -0x1c(%rbp),%edx
mov    %edx,%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x18(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1194 <ft_range+0x84>
mov    -0x28(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ft_range>:
push   %r14
push   %rbx
push   %rax
cmp    %edi,%esi
jle    1149 <ft_range+0x39>
mov    %esi,%r14d
mov    %edi,%ebx
sub    %edi,%r14d
js     1149 <ft_range+0x39>
lea    0x0(,%r14,4),%edi
call   1030 <malloc@plt>
test   %rax,%rax
je     1149 <ft_range+0x39>
test   %r14d,%r14d
je     114b <ft_range+0x3b>
mov    %r14d,%ecx
cmp    $0x8,%r14d
jae    1153 <ft_range+0x43>
xor    %edx,%edx
jmp    12b0 <ft_range+0x1a0>
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret
mov    %ecx,%edx
and    $0xfffffff8,%edx
movd   %ebx,%xmm0
pshufd $0x0,%xmm0,%xmm0
paddd  0xe97(%rip),%xmm0
lea    -0x8(%rdx),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%r8d
and    $0x3,%r8d
cmp    $0x18,%rsi
jae    118c <ft_range+0x7c>
xor    %esi,%esi
jmp    1258 <ft_range+0x148>
and    $0xfffffffffffffffc,%rdi
xor    %esi,%esi
movdqa 0xe75(%rip),%xmm8
movdqa 0xe7c(%rip),%xmm9
movdqa 0xe83(%rip),%xmm10
movdqa 0xe8b(%rip),%xmm4
movdqa 0xe93(%rip),%xmm5
movdqa 0xe9b(%rip),%xmm6
movdqa 0xea3(%rip),%xmm7
movdqa 0xeab(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,(%rax,%rsi,4)
movdqu %xmm2,0x10(%rax,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%rax,%rsi,4)
movdqu %xmm3,0x30(%rax,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%rax,%rsi,4)
movdqu %xmm3,0x50(%rax,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%rax,%rsi,4)
movdqu %xmm3,0x70(%rax,%rsi,4)
add    $0x20,%rsi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rdi
jne    11e0 <ft_range+0xd0>
test   %r8,%r8
je     12a0 <ft_range+0x190>
lea    (%rax,%rsi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%r8
xor    %edi,%edi
movdqa 0xd9d(%rip),%xmm1
movdqa 0xda5(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rsi,%rdi,1)
movdqu %xmm3,(%rsi,%rdi,1)
paddd  %xmm2,%xmm0
add    $0x20,%rdi
cmp    %rdi,%r8
jne    1280 <ft_range+0x170>
cmp    %rcx,%rdx
je     114b <ft_range+0x3b>
add    %edx,%ebx
nopl   0x0(%rax,%rax,1)
mov    %ebx,(%rax,%rdx,4)
add    $0x1,%rdx
add    $0x1,%ebx
cmp    %rdx,%rcx
jne    12b0 <ft_range+0x1a0>
jmp    114b <ft_range+0x3b>

LLVM IR (-O0):
define i32* @ft_range(i32 %0, i32 %1) {
%3 = alloca i32*
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32*
store i32 %0, i32* %4
store i32 %1, i32* %5
%10 = load i32, i32* %4
%11 = load i32, i32* %5
%12 = icmp sge i32 %10, %11
br i1 %12, label %13, label %14
13: ; preds = %2
store i32* null, i32** %3
br label %46
14: ; preds = %2
store i32 0, i32* %7
%15 = load i32, i32* %4
store i32 %15, i32* %8
%16 = load i32, i32* %5
%17 = load i32, i32* %4
%18 = sub nsw i32 %16, %17
store i32 %18, i32* %6
%19 = load i32, i32* %6
%20 = icmp slt i32 %19, 0
br i1 %20, label %21, label %22
21: ; preds = %14
store i32* null, i32** %3
br label %46
22: ; preds = %14
%23 = load i32, i32* %6
%24 = sext i32 %23 to i64
%25 = mul i64 %24, 4
%26 = trunc i64 %25 to i32
%27 = call i32* @malloc(i32 %26)
store i32* %27, i32** %9
%28 = load i32*, i32** %9
%29 = icmp eq i32* %28, null
br i1 %29, label %30, label %31
30: ; preds = %22
store i32* null, i32** %3
br label %46
31: ; preds = %22
br label %32
32: ; preds = %36, %31
%33 = load i32, i32* %7
%34 = load i32, i32* %6
%35 = icmp slt i32 %33, %34
br i1 %35, label %36, label %44
36: ; preds = %32
%37 = load i32, i32* %8
%38 = add nsw i32 %37, 1
store i32 %38, i32* %8
%39 = load i32*, i32** %9
%40 = load i32, i32* %7
%41 = add nsw i32 %40, 1
store i32 %41, i32* %7
%42 = sext i32 %40 to i64
%43 = getelementptr inbounds i32, i32* %39, i64 %42
store i32 %37, i32* %43
br label %32
44: ; preds = %32
%45 = load i32*, i32** %9
store i32* %45, i32** %3
br label %46
46: ; preds = %44, %30, %21, %13
%47 = load i32*, i32** %3
ret i32* %47
}

LLVM IR (-O2):
define noalias i32* @ft_range(i32 %0, i32 %1) {
%3 = icmp sgt i32 %1, %0
br i1 %3, label %4, label %93
4: ; preds = %2
%5 = sub i32 %1, %0
%6 = icmp slt i32 %5, 0
br i1 %6, label %93, label %7
7: ; preds = %4
%8 = shl i32 %5, 2
%9 = tail call i32* @malloc(i32 %8)
%10 = icmp eq i32* %9, null
br i1 %10, label %93, label %11
11: ; preds = %7
%12 = icmp eq i32 %5, 0
br i1 %12, label %93, label %13
13: ; preds = %11
%14 = zext i32 %5 to i64
%15 = icmp ult i32 %5, 8
br i1 %15, label %83, label %16
16: ; preds = %13
%17 = and i64 %14, 4294967288
%18 = trunc i64 %17 to i32
%19 = add i32 %18, %0
%20 = insertelement <4 x i32> poison, i32 %0, i64 0
%21 = shufflevector <4 x i32> %20, <4 x i32> poison, <4 x i32> zeroinitializer
%22 = add <4 x i32> %21, <i32 0, i32 1, i32 2, i32 3>
%23 = add nsw i64 %17, -8
%24 = lshr exact i64 %23, 3
%25 = add nuw nsw i64 %24, 1
%26 = and i64 %25, 3
%27 = icmp ult i64 %23, 24
br i1 %27, label %64, label %28
28: ; preds = %16
%29 = and i64 %25, 4611686018427387900
br label %30
30: ; preds = %30, %28
%31 = phi i64 [ 0, %28 ], [ %60, %30 ]
%32 = phi <4 x i32> [ %22, %28 ], [ %61, %30 ]
%33 = phi i64 [ 0, %28 ], [ %62, %30 ]
%34 = add <4 x i32> %32, <i32 4, i32 4, i32 4, i32 4>
%35 = getelementptr inbounds i32, i32* %9, i64 %31
%36 = bitcast i32* %35 to <4 x i32>*
store <4 x i32> %32, <4 x i32>* %36
%37 = getelementptr inbounds i32, i32* %35, i64 4
%38 = bitcast i32* %37 to <4 x i32>*
store <4 x i32> %34, <4 x i32>* %38
%39 = or i64 %31, 8
%40 = add <4 x i32> %32, <i32 8, i32 8, i32 8, i32 8>
%41 = add <4 x i32> %32, <i32 12, i32 12, i32 12, i32 12>
%42 = getelementptr inbounds i32, i32* %9, i64 %39
%43 = bitcast i32* %42 to <4 x i32>*
store <4 x i32> %40, <4 x i32>* %43
%44 = getelementptr inbounds i32, i32* %42, i64 4
%45 = bitcast i32* %44 to <4 x i32>*
store <4 x i32> %41, <4 x i32>* %45
%46 = or i64 %31, 16
%47 = add <4 x i32> %32, <i32 16, i32 16, i32 16, i32 16>
%48 = add <4 x i32> %32, <i32 20, i32 20, i32 20, i32 20>
%49 = getelementptr inbounds i32, i32* %9, i64 %46
%50 = bitcast i32* %49 to <4 x i32>*
store <4 x i32> %47, <4 x i32>* %50
%51 = getelementptr inbounds i32, i32* %49, i64 4
%52 = bitcast i32* %51 to <4 x i32>*
store <4 x i32> %48, <4 x i32>* %52
%53 = or i64 %31, 24
%54 = add <4 x i32> %32, <i32 24, i32 24, i32 24, i32 24>
%55 = add <4 x i32> %32, <i32 28, i32 28, i32 28, i32 28>
%56 = getelementptr inbounds i32, i32* %9, i64 %53
%57 = bitcast i32* %56 to <4 x i32>*
store <4 x i32> %54, <4 x i32>* %57
%58 = getelementptr inbounds i32, i32* %56, i64 4
%59 = bitcast i32* %58 to <4 x i32>*
store <4 x i32> %55, <4 x i32>* %59
%60 = add nuw i64 %31, 32
%61 = add <4 x i32> %32, <i32 32, i32 32, i32 32, i32 32>
%62 = add i64 %33, 4
%63 = icmp eq i64 %62, %29
br i1 %63, label %64, label %30
64: ; preds = %30, %16
%65 = phi i64 [ 0, %16 ], [ %60, %30 ]
%66 = phi <4 x i32> [ %22, %16 ], [ %61, %30 ]
%67 = icmp eq i64 %26, 0
br i1 %67, label %81, label %68
68: ; preds = %64, %68
%69 = phi i64 [ %77, %68 ], [ %65, %64 ]
%70 = phi <4 x i32> [ %78, %68 ], [ %66, %64 ]
%71 = phi i64 [ %79, %68 ], [ 0, %64 ]
%72 = add <4 x i32> %70, <i32 4, i32 4, i32 4, i32 4>
%73 = getelementptr inbounds i32, i32* %9, i64 %69
%74 = bitcast i32* %73 to <4 x i32>*
store <4 x i32> %70, <4 x i32>* %74
%75 = getelementptr inbounds i32, i32* %73, i64 4
%76 = bitcast i32* %75 to <4 x i32>*
store <4 x i32> %72, <4 x i32>* %76
%77 = add nuw i64 %69, 8
%78 = add <4 x i32> %70, <i32 8, i32 8, i32 8, i32 8>
%79 = add i64 %71, 1
%80 = icmp eq i64 %79, %26
br i1 %80, label %81, label %68
81: ; preds = %68, %64
%82 = icmp eq i64 %17, %14
br i1 %82, label %93, label %83
83: ; preds = %13, %81
%84 = phi i64 [ 0, %13 ], [ %17, %81 ]
%85 = phi i32 [ %0, %13 ], [ %19, %81 ]
br label %86
86: ; preds = %83, %86
%87 = phi i64 [ %90, %86 ], [ %84, %83 ]
%88 = phi i32 [ %89, %86 ], [ %85, %83 ]
%89 = add nsw i32 %88, 1
%90 = add nuw nsw i64 %87, 1
%91 = getelementptr inbounds i32, i32* %9, i64 %87
store i32 %88, i32* %91
%92 = icmp eq i64 %90, %14
br i1 %92, label %93, label %86
93: ; preds = %86, %81, %11, %7, %4, %2
%94 = phi i32* [ null, %2 ], [ null, %4 ], [ null, %7 ], [ %9, %11 ], [ %9, %81 ], [ %9, %86 ]
ret i32* %94
}