void RKMath_MinMax(float min_vec[], float max_vec[], float vec_a[],
                   float vec_b[], const int size) {
  int i = 0;
  while (i < size) {
    min_vec[i] = (vec_a[i] < vec_b[i]) ? vec_a[i] : vec_b[i];
    max_vec[i] = (vec_a[i] > vec_b[i]) ? vec_a[i] : vec_b[i];
    i++;
  }
}


x86 assembly (clang, -O0):
<RKMath_MinMax>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    11f1 <RKMath_MinMax+0xf1>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    1165 <RKMath_MinMax+0x65>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x2c(%rbp)
jmp    1177 <RKMath_MinMax+0x77>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x2c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    11bf <RKMath_MinMax+0xbf>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x30(%rbp)
jmp    11d1 <RKMath_MinMax+0xd1>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    111f <RKMath_MinMax+0x1f>
pop    %rbp
ret

x86 assembly (clang, -O2):
<RKMath_MinMax>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
test   %r8d,%r8d
jle    12eb <RKMath_MinMax+0x1eb>
mov    %r8d,%r9d
cmp    $0x4,%r8d
jae    11b0 <RKMath_MinMax+0xb0>
xor    %eax,%eax
mov    %rax,%r8
not    %r8
test   $0x1,%r9b
je     1150 <RKMath_MinMax+0x50>
movss  (%rdx,%rax,4),%xmm0
minss  (%rcx,%rax,4),%xmm0
movss  %xmm0,(%rdi,%rax,4)
movss  (%rdx,%rax,4),%xmm0
maxss  (%rcx,%rax,4),%xmm0
movss  %xmm0,(%rsi,%rax,4)
or     $0x1,%rax
add    %r9,%r8
je     12eb <RKMath_MinMax+0x1eb>
nopl   0x0(%rax)
movss  (%rdx,%rax,4),%xmm0
minss  (%rcx,%rax,4),%xmm0
movss  %xmm0,(%rdi,%rax,4)
movss  (%rdx,%rax,4),%xmm0
maxss  (%rcx,%rax,4),%xmm0
movss  %xmm0,(%rsi,%rax,4)
movss  0x4(%rdx,%rax,4),%xmm0
minss  0x4(%rcx,%rax,4),%xmm0
movss  %xmm0,0x4(%rdi,%rax,4)
movss  0x4(%rdx,%rax,4),%xmm0
maxss  0x4(%rcx,%rax,4),%xmm0
movss  %xmm0,0x4(%rsi,%rax,4)
add    $0x2,%rax
cmp    %rax,%r9
jne    1160 <RKMath_MinMax+0x60>
jmp    12eb <RKMath_MinMax+0x1eb>
lea    (%rsi,%r9,4),%rax
cmp    %rdi,%rax
seta   -0x1(%rsp)
lea    (%rdi,%r9,4),%rbx
cmp    %rsi,%rbx
seta   %r12b
lea    (%rdx,%r9,4),%rbp
cmp    %rdi,%rbp
seta   %r8b
cmp    %rdx,%rbx
seta   %r15b
lea    (%rcx,%r9,4),%r14
cmp    %rdi,%r14
seta   %r10b
cmp    %rcx,%rbx
seta   %r13b
cmp    %rsi,%rbp
seta   %r11b
cmp    %rdx,%rax
seta   %bpl
cmp    %rsi,%r14
seta   %bl
cmp    %rcx,%rax
seta   %r14b
xor    %eax,%eax
test   %r12b,-0x1(%rsp)
jne    1122 <RKMath_MinMax+0x22>
and    %r15b,%r8b
jne    1122 <RKMath_MinMax+0x22>
and    %r13b,%r10b
jne    1122 <RKMath_MinMax+0x22>
and    %bpl,%r11b
jne    1122 <RKMath_MinMax+0x22>
and    %r14b,%bl
jne    1122 <RKMath_MinMax+0x22>
mov    %r9d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rbp
mov    %rbp,%r10
shr    $0x2,%r10
add    $0x1,%r10
test   %rbp,%rbp
je     12f6 <RKMath_MinMax+0x1f6>
mov    %r10,%r11
and    $0xfffffffffffffffe,%r11
xor    %r8d,%r8d
nop
movups (%rdx,%r8,4),%xmm0
movups (%rcx,%r8,4),%xmm1
minps  %xmm1,%xmm0
movups %xmm0,(%rdi,%r8,4)
movups (%rdx,%r8,4),%xmm0
movups (%rcx,%r8,4),%xmm1
maxps  %xmm1,%xmm0
movups %xmm0,(%rsi,%r8,4)
movups 0x10(%rdx,%r8,4),%xmm0
movups 0x10(%rcx,%r8,4),%xmm1
minps  %xmm1,%xmm0
movups %xmm0,0x10(%rdi,%r8,4)
movups 0x10(%rdx,%r8,4),%xmm0
movups 0x10(%rcx,%r8,4),%xmm1
maxps  %xmm1,%xmm0
movups %xmm0,0x10(%rsi,%r8,4)
add    $0x8,%r8
add    $0xfffffffffffffffe,%r11
jne    1260 <RKMath_MinMax+0x160>
test   $0x1,%r10b
je     12e2 <RKMath_MinMax+0x1e2>
movups (%rdx,%r8,4),%xmm0
movups (%rcx,%r8,4),%xmm1
minps  %xmm1,%xmm0
movups %xmm0,(%rdi,%r8,4)
movups (%rdx,%r8,4),%xmm0
movups (%rcx,%r8,4),%xmm1
maxps  %xmm1,%xmm0
movups %xmm0,(%rsi,%r8,4)
cmp    %r9,%rax
jne    1122 <RKMath_MinMax+0x22>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %r8d,%r8d
test   $0x1,%r10b
jne    12be <RKMath_MinMax+0x1be>
jmp    12e2 <RKMath_MinMax+0x1e2>

LLVM IR (-O0):
define void @RKMath_MinMax(float* %0, float* %1, float* %2, float* %3, i32 %4) {
%6 = alloca float*
%7 = alloca float*
%8 = alloca float*
%9 = alloca float*
%10 = alloca i32
%11 = alloca i32
store float* %0, float** %6
store float* %1, float** %7
store float* %2, float** %8
store float* %3, float** %9
store i32 %4, i32* %10
store i32 0, i32* %11
br label %12
12: ; preds = %69, %5
%13 = load i32, i32* %11
%14 = load i32, i32* %10
%15 = icmp slt i32 %13, %14
br i1 %15, label %16, label %77
16: ; preds = %12
%17 = load float*, float** %8
%18 = load i32, i32* %11
%19 = sext i32 %18 to i64
%20 = getelementptr inbounds float, float* %17, i64 %19
%21 = load float, float* %20
%22 = load float*, float** %9
%23 = load i32, i32* %11
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds float, float* %22, i64 %24
%26 = load float, float* %25
%27 = fcmp olt float %21, %26
br i1 %27, label %28, label %34
28: ; preds = %16
%29 = load float*, float** %8
%30 = load i32, i32* %11
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds float, float* %29, i64 %31
%33 = load float, float* %32
br label %40
34: ; preds = %16
%35 = load float*, float** %9
%36 = load i32, i32* %11
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds float, float* %35, i64 %37
%39 = load float, float* %38
br label %40
40: ; preds = %34, %28
%41 = phi float [ %33, %28 ], [ %39, %34 ]
%42 = load float*, float** %6
%43 = load i32, i32* %11
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds float, float* %42, i64 %44
store float %41, float* %45
%46 = load float*, float** %8
%47 = load i32, i32* %11
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds float, float* %46, i64 %48
%50 = load float, float* %49
%51 = load float*, float** %9
%52 = load i32, i32* %11
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds float, float* %51, i64 %53
%55 = load float, float* %54
%56 = fcmp ogt float %50, %55
br i1 %56, label %57, label %63
57: ; preds = %40
%58 = load float*, float** %8
%59 = load i32, i32* %11
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds float, float* %58, i64 %60
%62 = load float, float* %61
br label %69
63: ; preds = %40
%64 = load float*, float** %9
%65 = load i32, i32* %11
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds float, float* %64, i64 %66
%68 = load float, float* %67
br label %69
69: ; preds = %63, %57
%70 = phi float [ %62, %57 ], [ %68, %63 ]
%71 = load float*, float** %7
%72 = load i32, i32* %11
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds float, float* %71, i64 %73
store float %70, float* %74
%75 = load i32, i32* %11
%76 = add nsw i32 %75, 1
store i32 %76, i32* %11
br label %12
77: ; preds = %12
ret void
}

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