#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 rand();
int /*<<< orphan*/ srand(int /*<<< orphan*/);
int /*<<< orphan*/ time(int /*<<< orphan*/ *);
void fill_with_numbers(int *nums, int modulo, int grenze) {
  srand(time(NULL));
  int i, j;
  for (i = 0; i < grenze; i++) {
    if (*(nums + i) >= 0)
      continue;
    while (1) {
      int tmp = rand() % modulo;
      int ok = 1;
      for (j = 0; j < i; j++) {
        if (*(nums + j) == tmp)
          ok = 0;
      }
      if (ok) {
        *(nums + i) = tmp;
        break;
      }
    }
  }
}


x86 assembly (clang, -O0):
<fill_with_numbers>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
xor    %eax,%eax
mov    %eax,%edi
call   1040 <time@plt>
mov    %eax,%edi
call   1030 <srand@plt>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    120c <fill_with_numbers+0xdc>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jl     117c <fill_with_numbers+0x4c>
jmp    11fe <fill_with_numbers+0xce>
jmp    1181 <fill_with_numbers+0x51>
mov    $0x0,%al
call   1050 <rand@plt>
cltd
idivl  -0xc(%rbp)
mov    %edx,-0x1c(%rbp)
movl   $0x1,-0x20(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11d7 <fill_with_numbers+0xa7>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x1c(%rbp),%eax
jne    11c4 <fill_with_numbers+0x94>
movl   $0x0,-0x20(%rbp)
jmp    11c9 <fill_with_numbers+0x99>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    119d <fill_with_numbers+0x6d>
cmpl   $0x0,-0x20(%rbp)
je     11f4 <fill_with_numbers+0xc4>
mov    -0x1c(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    11f9 <fill_with_numbers+0xc9>
jmp    1181 <fill_with_numbers+0x51>
jmp    11fe <fill_with_numbers+0xce>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1159 <fill_with_numbers+0x29>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fill_with_numbers>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %edx,%r14d
mov    %esi,0x4(%rsp)
mov    %rdi,%rbx
xor    %r13d,%r13d
xor    %edi,%edi
call   1040 <time@plt>
mov    %eax,%edi
call   1030 <srand@plt>
test   %r14d,%r14d
jle    130f <fill_with_numbers+0x1df>
mov    %r14d,%eax
xor    %ebp,%ebp
mov    %rax,0x8(%rsp)
jmp    1185 <fill_with_numbers+0x55>
xchg   %ax,%ax
mov    %edx,(%rbx,%rbp,4)
mov    0x8(%rsp),%rax
add    $0x1,%rbp
cmp    %rax,%rbp
je     130f <fill_with_numbers+0x1df>
cmpl   $0x0,(%rbx,%rbp,4)
jns    1178 <fill_with_numbers+0x48>
mov    %rbp,%r12
and    $0xfffffffffffffff8,%r12
add    $0xfffffffffffffff8,%r12
shr    $0x3,%r12
add    $0x1,%r12
and    $0xfffffffffffffffe,%r12
mov    %rbp,%r14
movabs $0x7ffffffffffffff8,%rax
ff ff 7f
and    %rax,%r14
lea    -0x8(%r14),%r15
mov    %r15,0x10(%rsp)
shr    $0x3,%r15
add    $0x1,%r15
jmp    11d4 <fill_with_numbers+0xa4>
cs nopw 0x0(%rax,%rax,1)
nop
test   %eax,%eax
jne    1170 <fill_with_numbers+0x40>
xor    %eax,%eax
call   1050 <rand@plt>
cltd
idivl  0x4(%rsp)
test   %rbp,%rbp
je     1170 <fill_with_numbers+0x40>
cmp    $0x8,%rbp
jae    1200 <fill_with_numbers+0xd0>
mov    $0x1,%eax
xor    %ecx,%ecx
jmp    12e0 <fill_with_numbers+0x1b0>
nopw   0x0(%rax,%rax,1)
movd   %edx,%xmm0
pshufd $0x0,%xmm0,%xmm0
cmpq   $0x0,0x10(%rsp)
je     12f5 <fill_with_numbers+0x1c5>
mov    %r12,%rcx
xor    %eax,%eax
movdqa 0xdde(%rip),%xmm3
movdqa %xmm3,%xmm4
cs nopw 0x0(%rax,%rax,1)
movdqu (%rbx,%rax,4),%xmm5
movdqu 0x10(%rbx,%rax,4),%xmm6
movdqu 0x20(%rbx,%rax,4),%xmm2
movdqu 0x30(%rbx,%rax,4),%xmm1
pcmpeqd %xmm0,%xmm5
pcmpeqd %xmm0,%xmm6
pcmpeqd %xmm0,%xmm2
por    %xmm5,%xmm2
pandn  %xmm4,%xmm2
pcmpeqd %xmm0,%xmm1
por    %xmm6,%xmm1
pandn  %xmm3,%xmm1
add    $0x10,%rax
movdqa %xmm2,%xmm4
movdqa %xmm1,%xmm3
add    $0xfffffffffffffffe,%rcx
jne    1230 <fill_with_numbers+0x100>
test   $0x1,%r15b
je     12a2 <fill_with_numbers+0x172>
movdqu (%rbx,%rax,4),%xmm3
movdqu 0x10(%rbx,%rax,4),%xmm4
pcmpeqd %xmm0,%xmm3
pandn  %xmm2,%xmm3
pcmpeqd %xmm0,%xmm4
pandn  %xmm1,%xmm4
movdqa %xmm3,%xmm2
movdqa %xmm4,%xmm1
movdqa %xmm2,%xmm0
movdqa 0xd52(%rip),%xmm3
pcmpeqd %xmm3,%xmm0
pand   %xmm0,%xmm1
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
pcmpeqd %xmm3,%xmm0
movmskps %xmm0,%ecx
xor    %eax,%eax
cmp    $0xf,%ecx
sete   %al
mov    %r14,%rcx
cmp    %r14,%rbp
je     11d0 <fill_with_numbers+0xa0>
nopl   0x0(%rax)
cmp    %edx,(%rbx,%rcx,4)
cmove  %r13d,%eax
add    $0x1,%rcx
cmp    %rcx,%rbp
jne    12e0 <fill_with_numbers+0x1b0>
jmp    11d0 <fill_with_numbers+0xa0>
xor    %eax,%eax
movdqa 0xd01(%rip),%xmm1
movdqa %xmm1,%xmm2
test   $0x1,%r15b
jne    127f <fill_with_numbers+0x14f>
jmp    12a2 <fill_with_numbers+0x172>
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @fill_with_numbers(i32* %0, i32 %1, i32 %2) {
%4 = alloca i32*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
store i32* %0, i32** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
%11 = call i32 @time(i32* null)
%12 = call i32 @srand(i32 %11)
store i32 0, i32* %7
br label %13
13: ; preds = %58, %3
%14 = load i32, i32* %7
%15 = load i32, i32* %6
%16 = icmp slt i32 %14, %15
br i1 %16, label %17, label %61
17: ; preds = %13
%18 = load i32*, i32** %4
%19 = load i32, i32* %7
%20 = sext i32 %19 to i64
%21 = getelementptr inbounds i32, i32* %18, i64 %20
%22 = load i32, i32* %21
%23 = icmp sge i32 %22, 0
br i1 %23, label %24, label %25
24: ; preds = %17
br label %58
25: ; preds = %17
br label %26
26: ; preds = %25, %56
%27 = call i32 (...) @rand()
%28 = load i32, i32* %5
%29 = srem i32 %27, %28
store i32 %29, i32* %9
store i32 1, i32* %10
store i32 0, i32* %8
br label %30
30: ; preds = %44, %26
%31 = load i32, i32* %8
%32 = load i32, i32* %7
%33 = icmp slt i32 %31, %32
br i1 %33, label %34, label %47
34: ; preds = %30
%35 = load i32*, i32** %4
%36 = load i32, i32* %8
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds i32, i32* %35, i64 %37
%39 = load i32, i32* %38
%40 = load i32, i32* %9
%41 = icmp eq i32 %39, %40
br i1 %41, label %42, label %43
42: ; preds = %34
store i32 0, i32* %10
br label %43
43: ; preds = %42, %34
br label %44
44: ; preds = %43
%45 = load i32, i32* %8
%46 = add nsw i32 %45, 1
store i32 %46, i32* %8
br label %30
47: ; preds = %30
%48 = load i32, i32* %10
%49 = icmp ne i32 %48, 0
br i1 %49, label %50, label %56
50: ; preds = %47
%51 = load i32, i32* %9
%52 = load i32*, i32** %4
%53 = load i32, i32* %7
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds i32, i32* %52, i64 %54
store i32 %51, i32* %55
br label %57
56: ; preds = %47
br label %26
57: ; preds = %50
br label %58
58: ; preds = %57, %24
%59 = load i32, i32* %7
%60 = add nsw i32 %59, 1
store i32 %60, i32* %7
br label %13
61: ; preds = %13
ret void
}

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