int escojer(int cl, float **dat, float **mat, int fc[]) {
  int f = 0;
  for (int i = 0; i < fc[0]; i++) {
    if (dat[i][0] == cl) {
      for (int j = 1; j < fc[1]; j++)
        mat[f][j - 1] = dat[i][j];
      f++;
    }
  }
  return 1;
}


x86 assembly (clang, -O0):
<escojer>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x20(%rbp),%rcx
cmp    (%rcx),%eax
jge    11c4 <escojer+0xc4>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  (%rax),%xmm0
cvtsi2ssl -0x4(%rbp),%xmm1
ucomiss %xmm1,%xmm0
jne    11b1 <escojer+0xb1>
jp     11b1 <escojer+0xb1>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x20(%rbp),%rcx
cmp    0x4(%rcx),%eax
jge    11a8 <escojer+0xa8>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    115b <escojer+0x5b>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11b6 <escojer+0xb6>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1121 <escojer+0x21>
mov    $0x1,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<escojer>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    (%rcx),%r8d
test   %r8d,%r8d
jle    1301 <escojer+0x201>
cvtsi2ss %edi,%xmm0
xor    %r11d,%r11d
xor    %r9d,%r9d
jmp    1141 <escojer+0x41>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r9d
add    $0x1,%r11
cmp    %r8,%r11
je     1301 <escojer+0x201>
mov    (%rsi,%r11,8),%r12
movss  (%r12),%xmm1
ucomiss %xmm0,%xmm1
jne    1134 <escojer+0x34>
jp     1134 <escojer+0x34>
mov    0x4(%rcx),%r10d
cmp    $0x2,%r10d
jl     1130 <escojer+0x30>
movslq %r9d,%rax
mov    (%rdx,%rax,8),%rbp
lea    -0x1(%r10),%r14
mov    $0x1,%ebx
cmp    $0x8,%r14
jb     1280 <escojer+0x180>
lea    (%r12,%r10,4),%rax
cmp    %rax,%rbp
jae    1198 <escojer+0x98>
lea    -0x4(,%r10,4),%r15
ff
add    %rbp,%r15
lea    0x4(%r12),%rax
cmp    %r15,%rax
jb     1280 <escojer+0x180>
mov    %r14,%rbx
and    $0xfffffffffffffff8,%rbx
lea    -0x8(%rbx),%rax
mov    %rax,%r13
shr    $0x3,%r13
add    $0x1,%r13
mov    %r13d,%r15d
and    $0x3,%r15d
cmp    $0x18,%rax
jae    11bf <escojer+0xbf>
xor    %eax,%eax
jmp    1232 <escojer+0x132>
and    $0xfffffffffffffffc,%r13
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movups 0x4(%r12,%rax,4),%xmm1
movups 0x14(%r12,%rax,4),%xmm2
movups %xmm1,0x0(%rbp,%rax,4)
movups %xmm2,0x10(%rbp,%rax,4)
movups 0x24(%r12,%rax,4),%xmm1
movups 0x34(%r12,%rax,4),%xmm2
movups %xmm1,0x20(%rbp,%rax,4)
movups %xmm2,0x30(%rbp,%rax,4)
movups 0x44(%r12,%rax,4),%xmm1
movups 0x54(%r12,%rax,4),%xmm2
movups %xmm1,0x40(%rbp,%rax,4)
movups %xmm2,0x50(%rbp,%rax,4)
movups 0x64(%r12,%rax,4),%xmm1
movups 0x74(%r12,%rax,4),%xmm2
movups %xmm1,0x60(%rbp,%rax,4)
movups %xmm2,0x70(%rbp,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r13
jne    11d0 <escojer+0xd0>
test   %r15,%r15
je     126b <escojer+0x16b>
nopw   0x0(%rax,%rax,1)
lea    0x0(,%rax,4),%rdi
or     $0x4,%rdi
movups (%r12,%rdi,1),%xmm1
movups 0x10(%r12,%rdi,1),%xmm2
movups %xmm1,0x0(%rbp,%rax,4)
movups %xmm2,0x10(%rbp,%rax,4)
add    $0x8,%rax
add    $0xffffffffffffffff,%r15
jne    1240 <escojer+0x140>
cmp    %rbx,%r14
je     1130 <escojer+0x30>
or     $0x1,%rbx
nopl   0x0(%rax,%rax,1)
mov    %r10d,%eax
sub    %ebx,%eax
mov    %rbx,%r14
not    %r14
add    %r10,%r14
and    $0x3,%rax
je     12b6 <escojer+0x1b6>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%r12,%rbx,4),%xmm1
movss  %xmm1,-0x4(%rbp,%rbx,4)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rax
jne    12a0 <escojer+0x1a0>
cmp    $0x3,%r14
jb     1130 <escojer+0x30>
movss  (%r12,%rbx,4),%xmm1
movss  %xmm1,-0x4(%rbp,%rbx,4)
movss  0x4(%r12,%rbx,4),%xmm1
movss  %xmm1,0x0(%rbp,%rbx,4)
movss  0x8(%r12,%rbx,4),%xmm1
movss  %xmm1,0x4(%rbp,%rbx,4)
movss  0xc(%r12,%rbx,4),%xmm1
movss  %xmm1,0x8(%rbp,%rbx,4)
add    $0x4,%rbx
cmp    %rbx,%r10
jne    12c0 <escojer+0x1c0>
jmp    1130 <escojer+0x30>
mov    $0x1,%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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