int minNi(int *array, int N) {
  int smallest;
  N -= 2;
  for (smallest = array[N + 1]; N >= 0; N--) {
    if (array[N] < smallest)
      smallest = array[N];
  }
  return smallest;
}


x86 assembly (clang, -O0):
<minNi>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0xc(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x10(%rbp)
cmpl   $0x0,-0xc(%rbp)
jl     1166 <minNi+0x66>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x10(%rbp),%eax
jge    1153 <minNi+0x53>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x10(%rbp)
jmp    1158 <minNi+0x58>
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
jmp    1127 <minNi+0x27>
mov    -0x10(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<minNi>:
movslq %esi,%rcx
mov    -0x4(%rdi,%rcx,4),%eax
cmp    $0x2,%ecx
jl     129e <minNi+0x19e>
add    $0xfffffffe,%esi
cmp    $0x7,%esi
jb     1290 <minNi+0x190>
lea    0x1(%rsi),%r8
mov    %r8,%r9
and    $0xfffffffffffffff8,%r9
movd   %eax,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%r9),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rax,%rax
je     129f <minNi+0x19f>
mov    %r10,%rax
and    $0xfffffffffffffffe,%rax
lea    (%rdi,%rsi,4),%rcx
add    $0xfffffffffffffff4,%rcx
xor    %edx,%edx
movdqa %xmm0,%xmm1
nopl   (%rax)
movdqu -0x30(%rcx,%rdx,4),%xmm2
movdqu -0x20(%rcx,%rdx,4),%xmm3
movdqu -0x10(%rcx,%rdx,4),%xmm4
movdqu (%rcx,%rdx,4),%xmm5
pshufd $0x1b,%xmm5,%xmm5
pshufd $0x1b,%xmm4,%xmm4
movdqa %xmm0,%xmm6
pcmpgtd %xmm5,%xmm6
pand   %xmm6,%xmm5
pandn  %xmm0,%xmm6
por    %xmm5,%xmm6
movdqa %xmm1,%xmm5
pcmpgtd %xmm4,%xmm5
pand   %xmm5,%xmm4
pandn  %xmm1,%xmm5
por    %xmm4,%xmm5
pshufd $0x1b,%xmm3,%xmm1
pshufd $0x1b,%xmm2,%xmm2
movdqa %xmm6,%xmm0
pcmpgtd %xmm1,%xmm0
pand   %xmm0,%xmm1
pandn  %xmm6,%xmm0
por    %xmm1,%xmm0
movdqa %xmm5,%xmm1
pcmpgtd %xmm2,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm5,%xmm1
por    %xmm2,%xmm1
add    $0xfffffffffffffff0,%rdx
add    $0xfffffffffffffffe,%rax
jne    1160 <minNi+0x60>
neg    %rdx
test   $0x1,%r10b
je     123e <minNi+0x13e>
mov    %rsi,%rax
sub    %rdx,%rax
movdqu -0x1c(%rdi,%rax,4),%xmm2
movdqu -0xc(%rdi,%rax,4),%xmm3
pshufd $0x1b,%xmm3,%xmm3
pshufd $0x1b,%xmm2,%xmm2
movdqa %xmm0,%xmm4
pcmpgtd %xmm3,%xmm4
pand   %xmm4,%xmm3
pandn  %xmm0,%xmm4
por    %xmm3,%xmm4
movdqa %xmm1,%xmm3
pcmpgtd %xmm2,%xmm3
pand   %xmm3,%xmm2
pandn  %xmm1,%xmm3
por    %xmm2,%xmm3
movdqa %xmm4,%xmm0
movdqa %xmm3,%xmm1
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm0
pandn  %xmm1,%xmm2
por    %xmm0,%xmm2
pshufd $0xee,%xmm2,%xmm0
movdqa %xmm0,%xmm1
pcmpgtd %xmm2,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm0,%xmm1
por    %xmm2,%xmm1
pshufd $0x55,%xmm1,%xmm0
movdqa %xmm0,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
movd   %xmm2,%eax
cmp    %r9,%r8
je     129e <minNi+0x19e>
sub    %r9,%rsi
mov    (%rdi,%rsi,4),%ecx
cmp    %eax,%ecx
cmovl  %ecx,%eax
add    $0xffffffffffffffff,%rsi
jb     1290 <minNi+0x190>
ret
xor    %edx,%edx
movdqa %xmm0,%xmm1
test   $0x1,%r10b
jne    11f2 <minNi+0xf2>
jmp    123e <minNi+0x13e>

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

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