float load_store_sf(unsigned long num, const float *from_ptr, float *to_ptr,
                    const unsigned long *in_mask_ptr,
                    const unsigned long *out_mask_ptr) {
  float value00 = 0.0f;
  float value01 = 0.0f;
  float value02 = 0.0f;
  float value03 = 0.0f;
  float value04 = 0.0f;
  float value05 = 0.0f;
  float value06 = 0.0f;
  float value07 = 0.0f;
  float value08 = 0.0f;
  float value09 = 0.0f;
  float value10 = 0.0f;
  float value11 = 0.0f;
  float value12 = 0.0f;
  float value13 = 0.0f;
  float value14 = 0.0f;
  float value15 = 0.0f;
  float value16 = 0.0f;
  float value17 = 0.0f;
  float value18 = 0.0f;
  float value19 = 0.0f;
  float value20 = 0.0f;
  float value21 = 0.0f;
  float value22 = 0.0f;
  float value23 = 0.0f;
  float value24 = 0.0f;
  float value25 = 0.0f;
  float value26 = 0.0f;
  float value27 = 0.0f;
  float value28 = 0.0f;
  float value29 = 0.0f;
  float value30 = 0.0f;
  float value31 = 0.0f;
  float value32 = 0.0f;
  float value33 = 0.0f;
  float value34 = 0.0f;
  float value35 = 0.0f;
  float value36 = 0.0f;
  float value37 = 0.0f;
  float value38 = 0.0f;
  float value39 = 0.0f;
  unsigned long in_mask, in_mask2;
  unsigned long out_mask, out_mask2;
  unsigned long i;
  for (i = 0; i < num; i++) {
    in_mask = *in_mask_ptr++;
    in_mask2 = *in_mask_ptr++;
    if ((in_mask & (1L << 0)) != 0L)
      value00 = *from_ptr++;
    if ((in_mask & (1L << 1)) != 0L)
      value01 = *from_ptr++;
    if ((in_mask & (1L << 2)) != 0L)
      value02 = *from_ptr++;
    if ((in_mask & (1L << 3)) != 0L)
      value03 = *from_ptr++;
    if ((in_mask & (1L << 4)) != 0L)
      value04 = *from_ptr++;
    if ((in_mask & (1L << 5)) != 0L)
      value05 = *from_ptr++;
    if ((in_mask & (1L << 6)) != 0L)
      value06 = *from_ptr++;
    if ((in_mask & (1L << 7)) != 0L)
      value07 = *from_ptr++;
    if ((in_mask & (1L << 8)) != 0L)
      value08 = *from_ptr++;
    if ((in_mask & (1L << 9)) != 0L)
      value09 = *from_ptr++;
    if ((in_mask & (1L << 10)) != 0L)
      value10 = *from_ptr++;
    if ((in_mask & (1L << 11)) != 0L)
      value11 = *from_ptr++;
    if ((in_mask & (1L << 12)) != 0L)
      value12 = *from_ptr++;
    if ((in_mask & (1L << 13)) != 0L)
      value13 = *from_ptr++;
    if ((in_mask & (1L << 14)) != 0L)
      value14 = *from_ptr++;
    if ((in_mask & (1L << 15)) != 0L)
      value15 = *from_ptr++;
    if ((in_mask & (1L << 16)) != 0L)
      value16 = *from_ptr++;
    if ((in_mask & (1L << 17)) != 0L)
      value17 = *from_ptr++;
    if ((in_mask & (1L << 18)) != 0L)
      value18 = *from_ptr++;
    if ((in_mask & (1L << 19)) != 0L)
      value19 = *from_ptr++;
    if ((in_mask2 & (1L << 0)) != 0L)
      value20 = *from_ptr++;
    if ((in_mask2 & (1L << 1)) != 0L)
      value21 = *from_ptr++;
    if ((in_mask2 & (1L << 2)) != 0L)
      value22 = *from_ptr++;
    if ((in_mask2 & (1L << 3)) != 0L)
      value23 = *from_ptr++;
    if ((in_mask2 & (1L << 4)) != 0L)
      value24 = *from_ptr++;
    if ((in_mask2 & (1L << 5)) != 0L)
      value25 = *from_ptr++;
    if ((in_mask2 & (1L << 6)) != 0L)
      value26 = *from_ptr++;
    if ((in_mask2 & (1L << 7)) != 0L)
      value27 = *from_ptr++;
    if ((in_mask2 & (1L << 8)) != 0L)
      value28 = *from_ptr++;
    if ((in_mask2 & (1L << 9)) != 0L)
      value29 = *from_ptr++;
    if ((in_mask2 & (1L << 10)) != 0L)
      value30 = *from_ptr++;
    if ((in_mask2 & (1L << 11)) != 0L)
      value31 = *from_ptr++;
    if ((in_mask2 & (1L << 12)) != 0L)
      value32 = *from_ptr++;
    if ((in_mask2 & (1L << 13)) != 0L)
      value33 = *from_ptr++;
    if ((in_mask2 & (1L << 14)) != 0L)
      value34 = *from_ptr++;
    if ((in_mask2 & (1L << 15)) != 0L)
      value35 = *from_ptr++;
    if ((in_mask2 & (1L << 16)) != 0L)
      value36 = *from_ptr++;
    if ((in_mask2 & (1L << 17)) != 0L)
      value37 = *from_ptr++;
    if ((in_mask2 & (1L << 18)) != 0L)
      value38 = *from_ptr++;
    if ((in_mask2 & (1L << 19)) != 0L)
      value39 = *from_ptr++;
    out_mask = *out_mask_ptr++;
    out_mask2 = *out_mask_ptr++;
    if ((out_mask & (1L << 0)) != 0L)
      *to_ptr++ = value00;
    if ((out_mask & (1L << 1)) != 0L)
      *to_ptr++ = value01;
    if ((out_mask & (1L << 2)) != 0L)
      *to_ptr++ = value02;
    if ((out_mask & (1L << 3)) != 0L)
      *to_ptr++ = value03;
    if ((out_mask & (1L << 4)) != 0L)
      *to_ptr++ = value04;
    if ((out_mask & (1L << 5)) != 0L)
      *to_ptr++ = value05;
    if ((out_mask & (1L << 6)) != 0L)
      *to_ptr++ = value06;
    if ((out_mask & (1L << 7)) != 0L)
      *to_ptr++ = value07;
    if ((out_mask & (1L << 8)) != 0L)
      *to_ptr++ = value08;
    if ((out_mask & (1L << 9)) != 0L)
      *to_ptr++ = value09;
    if ((out_mask & (1L << 10)) != 0L)
      *to_ptr++ = value10;
    if ((out_mask & (1L << 11)) != 0L)
      *to_ptr++ = value11;
    if ((out_mask & (1L << 12)) != 0L)
      *to_ptr++ = value12;
    if ((out_mask & (1L << 13)) != 0L)
      *to_ptr++ = value13;
    if ((out_mask & (1L << 14)) != 0L)
      *to_ptr++ = value14;
    if ((out_mask & (1L << 15)) != 0L)
      *to_ptr++ = value15;
    if ((out_mask & (1L << 16)) != 0L)
      *to_ptr++ = value16;
    if ((out_mask & (1L << 17)) != 0L)
      *to_ptr++ = value17;
    if ((out_mask & (1L << 18)) != 0L)
      *to_ptr++ = value18;
    if ((out_mask & (1L << 19)) != 0L)
      *to_ptr++ = value19;
    if ((out_mask2 & (1L << 0)) != 0L)
      *to_ptr++ = value20;
    if ((out_mask2 & (1L << 1)) != 0L)
      *to_ptr++ = value21;
    if ((out_mask2 & (1L << 2)) != 0L)
      *to_ptr++ = value22;
    if ((out_mask2 & (1L << 3)) != 0L)
      *to_ptr++ = value23;
    if ((out_mask2 & (1L << 4)) != 0L)
      *to_ptr++ = value24;
    if ((out_mask2 & (1L << 5)) != 0L)
      *to_ptr++ = value25;
    if ((out_mask2 & (1L << 6)) != 0L)
      *to_ptr++ = value26;
    if ((out_mask2 & (1L << 7)) != 0L)
      *to_ptr++ = value27;
    if ((out_mask2 & (1L << 8)) != 0L)
      *to_ptr++ = value28;
    if ((out_mask2 & (1L << 9)) != 0L)
      *to_ptr++ = value29;
    if ((out_mask2 & (1L << 10)) != 0L)
      *to_ptr++ = value30;
    if ((out_mask2 & (1L << 11)) != 0L)
      *to_ptr++ = value31;
    if ((out_mask2 & (1L << 12)) != 0L)
      *to_ptr++ = value32;
    if ((out_mask2 & (1L << 13)) != 0L)
      *to_ptr++ = value33;
    if ((out_mask2 & (1L << 14)) != 0L)
      *to_ptr++ = value34;
    if ((out_mask2 & (1L << 15)) != 0L)
      *to_ptr++ = value35;
    if ((out_mask2 & (1L << 16)) != 0L)
      *to_ptr++ = value36;
    if ((out_mask2 & (1L << 17)) != 0L)
      *to_ptr++ = value37;
    if ((out_mask2 & (1L << 18)) != 0L)
      *to_ptr++ = value38;
    if ((out_mask2 & (1L << 19)) != 0L)
      *to_ptr++ = value39;
  }
  return (value00 + value01 + value02 + value03 + value04 + value05 + value06 +
          value07 + value08 + value09 + value10 + value11 + value12 + value13 +
          value14 + value15 + value16 + value17 + value18 + value19 + value20 +
          value21 + value22 + value23 + value24 + value25 + value26 + value27 +
          value28 + value29 + value30 + value31 + value32 + value33 + value34 +
          value35 + value36 + value37 + value38 + value39);
}


x86 assembly (clang, -O0):
<load_store_sf>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x6c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xac(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xc0(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
movq   $0x0,-0xf0(%rbp)
mov    -0xf0(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    2212 <load_store_sf+0x1112>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%rax
mov    %rax,-0xd0(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%rax
mov    %rax,-0xd8(%rbp)
mov    -0xd0(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     130d <load_store_sf+0x20d>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0xd0(%rbp),%rax
and    $0x2,%rax
cmp    $0x0,%rax
je     133a <load_store_sf+0x23a>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0xd0(%rbp),%rax
and    $0x4,%rax
cmp    $0x0,%rax
je     1367 <load_store_sf+0x267>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0xd0(%rbp),%rax
and    $0x8,%rax
cmp    $0x0,%rax
je     1394 <load_store_sf+0x294>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0xd0(%rbp),%rax
and    $0x10,%rax
cmp    $0x0,%rax
je     13c1 <load_store_sf+0x2c1>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0xd0(%rbp),%rax
and    $0x20,%rax
cmp    $0x0,%rax
je     13ee <load_store_sf+0x2ee>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0xd0(%rbp),%rax
and    $0x40,%rax
cmp    $0x0,%rax
je     141b <load_store_sf+0x31b>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0xd0(%rbp),%rax
and    $0x80,%rax
cmp    $0x0,%rax
je     144a <load_store_sf+0x34a>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0xd0(%rbp),%rax
and    $0x100,%rax
cmp    $0x0,%rax
je     1479 <load_store_sf+0x379>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0xd0(%rbp),%rax
and    $0x200,%rax
cmp    $0x0,%rax
je     14a8 <load_store_sf+0x3a8>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0xd0(%rbp),%rax
and    $0x400,%rax
cmp    $0x0,%rax
je     14d7 <load_store_sf+0x3d7>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0xd0(%rbp),%rax
and    $0x800,%rax
cmp    $0x0,%rax
je     1506 <load_store_sf+0x406>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0xd0(%rbp),%rax
and    $0x1000,%rax
cmp    $0x0,%rax
je     1535 <load_store_sf+0x435>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0xd0(%rbp),%rax
and    $0x2000,%rax
cmp    $0x0,%rax
je     1564 <load_store_sf+0x464>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0xd0(%rbp),%rax
and    $0x4000,%rax
cmp    $0x0,%rax
je     1593 <load_store_sf+0x493>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0xd0(%rbp),%rax
and    $0x8000,%rax
cmp    $0x0,%rax
je     15c2 <load_store_sf+0x4c2>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0xd0(%rbp),%rax
and    $0x10000,%rax
cmp    $0x0,%rax
je     15f1 <load_store_sf+0x4f1>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0xd0(%rbp),%rax
and    $0x20000,%rax
cmp    $0x0,%rax
je     1620 <load_store_sf+0x520>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0xd0(%rbp),%rax
and    $0x40000,%rax
cmp    $0x0,%rax
je     164f <load_store_sf+0x54f>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0xd0(%rbp),%rax
and    $0x80000,%rax
cmp    $0x0,%rax
je     167e <load_store_sf+0x57e>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0xd8(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     16ab <load_store_sf+0x5ab>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0xd8(%rbp),%rax
and    $0x2,%rax
cmp    $0x0,%rax
je     16d8 <load_store_sf+0x5d8>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0xd8(%rbp),%rax
and    $0x4,%rax
cmp    $0x0,%rax
je     1708 <load_store_sf+0x608>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    -0xd8(%rbp),%rax
and    $0x8,%rax
cmp    $0x0,%rax
je     1738 <load_store_sf+0x638>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    -0xd8(%rbp),%rax
and    $0x10,%rax
cmp    $0x0,%rax
je     1768 <load_store_sf+0x668>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0xd8(%rbp),%rax
and    $0x20,%rax
cmp    $0x0,%rax
je     1798 <load_store_sf+0x698>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    -0xd8(%rbp),%rax
and    $0x40,%rax
cmp    $0x0,%rax
je     17c8 <load_store_sf+0x6c8>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0xd8(%rbp),%rax
and    $0x80,%rax
cmp    $0x0,%rax
je     17fa <load_store_sf+0x6fa>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    -0xd8(%rbp),%rax
and    $0x100,%rax
cmp    $0x0,%rax
je     182c <load_store_sf+0x72c>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
mov    -0xd8(%rbp),%rax
and    $0x200,%rax
cmp    $0x0,%rax
je     185e <load_store_sf+0x75e>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
mov    -0xd8(%rbp),%rax
and    $0x400,%rax
cmp    $0x0,%rax
je     1890 <load_store_sf+0x790>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
mov    -0xd8(%rbp),%rax
and    $0x800,%rax
cmp    $0x0,%rax
je     18c2 <load_store_sf+0x7c2>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
mov    -0xd8(%rbp),%rax
and    $0x1000,%rax
cmp    $0x0,%rax
je     18f4 <load_store_sf+0x7f4>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xac(%rbp)
ff
mov    -0xd8(%rbp),%rax
and    $0x2000,%rax
cmp    $0x0,%rax
je     1926 <load_store_sf+0x826>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
mov    -0xd8(%rbp),%rax
and    $0x4000,%rax
cmp    $0x0,%rax
je     1958 <load_store_sf+0x858>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
mov    -0xd8(%rbp),%rax
and    $0x8000,%rax
cmp    $0x0,%rax
je     198a <load_store_sf+0x88a>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
mov    -0xd8(%rbp),%rax
and    $0x10000,%rax
cmp    $0x0,%rax
je     19bc <load_store_sf+0x8bc>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
mov    -0xd8(%rbp),%rax
and    $0x20000,%rax
cmp    $0x0,%rax
je     19ee <load_store_sf+0x8ee>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xc0(%rbp)
ff
mov    -0xd8(%rbp),%rax
and    $0x40000,%rax
cmp    $0x0,%rax
je     1a20 <load_store_sf+0x920>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
mov    -0xd8(%rbp),%rax
and    $0x80000,%rax
cmp    $0x0,%rax
je     1a52 <load_store_sf+0x952>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%rax
mov    %rax,-0xe0(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%rax
mov    %rax,-0xe8(%rbp)
mov    -0xe0(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     1ab1 <load_store_sf+0x9b1>
movss  -0x2c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe0(%rbp),%rax
and    $0x2,%rax
cmp    $0x0,%rax
je     1ade <load_store_sf+0x9de>
movss  -0x30(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe0(%rbp),%rax
and    $0x4,%rax
cmp    $0x0,%rax
je     1b0b <load_store_sf+0xa0b>
movss  -0x34(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe0(%rbp),%rax
and    $0x8,%rax
cmp    $0x0,%rax
je     1b38 <load_store_sf+0xa38>
movss  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe0(%rbp),%rax
and    $0x10,%rax
cmp    $0x0,%rax
je     1b65 <load_store_sf+0xa65>
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe0(%rbp),%rax
and    $0x20,%rax
cmp    $0x0,%rax
je     1b92 <load_store_sf+0xa92>
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe0(%rbp),%rax
and    $0x40,%rax
cmp    $0x0,%rax
je     1bbf <load_store_sf+0xabf>
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe0(%rbp),%rax
and    $0x80,%rax
cmp    $0x0,%rax
je     1bee <load_store_sf+0xaee>
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe0(%rbp),%rax
and    $0x100,%rax
cmp    $0x0,%rax
je     1c1d <load_store_sf+0xb1d>
movss  -0x4c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe0(%rbp),%rax
and    $0x200,%rax
cmp    $0x0,%rax
je     1c4c <load_store_sf+0xb4c>
movss  -0x50(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe0(%rbp),%rax
and    $0x400,%rax
cmp    $0x0,%rax
je     1c7b <load_store_sf+0xb7b>
movss  -0x54(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe0(%rbp),%rax
and    $0x800,%rax
cmp    $0x0,%rax
je     1caa <load_store_sf+0xbaa>
movss  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe0(%rbp),%rax
and    $0x1000,%rax
cmp    $0x0,%rax
je     1cd9 <load_store_sf+0xbd9>
movss  -0x5c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe0(%rbp),%rax
and    $0x2000,%rax
cmp    $0x0,%rax
je     1d08 <load_store_sf+0xc08>
movss  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe0(%rbp),%rax
and    $0x4000,%rax
cmp    $0x0,%rax
je     1d37 <load_store_sf+0xc37>
movss  -0x64(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe0(%rbp),%rax
and    $0x8000,%rax
cmp    $0x0,%rax
je     1d66 <load_store_sf+0xc66>
movss  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe0(%rbp),%rax
and    $0x10000,%rax
cmp    $0x0,%rax
je     1d95 <load_store_sf+0xc95>
movss  -0x6c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe0(%rbp),%rax
and    $0x20000,%rax
cmp    $0x0,%rax
je     1dc4 <load_store_sf+0xcc4>
movss  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe0(%rbp),%rax
and    $0x40000,%rax
cmp    $0x0,%rax
je     1df3 <load_store_sf+0xcf3>
movss  -0x74(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe0(%rbp),%rax
and    $0x80000,%rax
cmp    $0x0,%rax
je     1e22 <load_store_sf+0xd22>
movss  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe8(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     1e4f <load_store_sf+0xd4f>
movss  -0x7c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe8(%rbp),%rax
and    $0x2,%rax
cmp    $0x0,%rax
je     1e7c <load_store_sf+0xd7c>
movss  -0x80(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe8(%rbp),%rax
and    $0x4,%rax
cmp    $0x0,%rax
je     1eac <load_store_sf+0xdac>
movss  -0x84(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe8(%rbp),%rax
and    $0x8,%rax
cmp    $0x0,%rax
je     1edc <load_store_sf+0xddc>
movss  -0x88(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe8(%rbp),%rax
and    $0x10,%rax
cmp    $0x0,%rax
je     1f0c <load_store_sf+0xe0c>
movss  -0x8c(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe8(%rbp),%rax
and    $0x20,%rax
cmp    $0x0,%rax
je     1f3c <load_store_sf+0xe3c>
movss  -0x90(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe8(%rbp),%rax
and    $0x40,%rax
cmp    $0x0,%rax
je     1f6c <load_store_sf+0xe6c>
movss  -0x94(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe8(%rbp),%rax
and    $0x80,%rax
cmp    $0x0,%rax
je     1f9e <load_store_sf+0xe9e>
movss  -0x98(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe8(%rbp),%rax
and    $0x100,%rax
cmp    $0x0,%rax
je     1fd0 <load_store_sf+0xed0>
movss  -0x9c(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe8(%rbp),%rax
and    $0x200,%rax
cmp    $0x0,%rax
je     2002 <load_store_sf+0xf02>
movss  -0xa0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe8(%rbp),%rax
and    $0x400,%rax
cmp    $0x0,%rax
je     2034 <load_store_sf+0xf34>
movss  -0xa4(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe8(%rbp),%rax
and    $0x800,%rax
cmp    $0x0,%rax
je     2066 <load_store_sf+0xf66>
movss  -0xa8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe8(%rbp),%rax
and    $0x1000,%rax
cmp    $0x0,%rax
je     2098 <load_store_sf+0xf98>
movss  -0xac(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe8(%rbp),%rax
and    $0x2000,%rax
cmp    $0x0,%rax
je     20ca <load_store_sf+0xfca>
movss  -0xb0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe8(%rbp),%rax
and    $0x4000,%rax
cmp    $0x0,%rax
je     20fc <load_store_sf+0xffc>
movss  -0xb4(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe8(%rbp),%rax
and    $0x8000,%rax
cmp    $0x0,%rax
je     212e <load_store_sf+0x102e>
movss  -0xb8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe8(%rbp),%rax
and    $0x10000,%rax
cmp    $0x0,%rax
je     2160 <load_store_sf+0x1060>
movss  -0xbc(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe8(%rbp),%rax
and    $0x20000,%rax
cmp    $0x0,%rax
je     2192 <load_store_sf+0x1092>
movss  -0xc0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe8(%rbp),%rax
and    $0x40000,%rax
cmp    $0x0,%rax
je     21c4 <load_store_sf+0x10c4>
movss  -0xc4(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xe8(%rbp),%rax
and    $0x80000,%rax
cmp    $0x0,%rax
je     21f6 <load_store_sf+0x10f6>
movss  -0xc8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
jmp    21fb <load_store_sf+0x10fb>
mov    -0xf0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xf0(%rbp)
jmp    129d <load_store_sf+0x19d>
movss  -0x2c(%rbp),%xmm0
addss  -0x30(%rbp),%xmm0
addss  -0x34(%rbp),%xmm0
addss  -0x38(%rbp),%xmm0
addss  -0x3c(%rbp),%xmm0
addss  -0x40(%rbp),%xmm0
addss  -0x44(%rbp),%xmm0
addss  -0x48(%rbp),%xmm0
addss  -0x4c(%rbp),%xmm0
addss  -0x50(%rbp),%xmm0
addss  -0x54(%rbp),%xmm0
addss  -0x58(%rbp),%xmm0
addss  -0x5c(%rbp),%xmm0
addss  -0x60(%rbp),%xmm0
addss  -0x64(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
addss  -0x6c(%rbp),%xmm0
addss  -0x70(%rbp),%xmm0
addss  -0x74(%rbp),%xmm0
addss  -0x78(%rbp),%xmm0
addss  -0x7c(%rbp),%xmm0
addss  -0x80(%rbp),%xmm0
addss  -0x84(%rbp),%xmm0
ff
addss  -0x88(%rbp),%xmm0
ff
addss  -0x8c(%rbp),%xmm0
ff
addss  -0x90(%rbp),%xmm0
ff
addss  -0x94(%rbp),%xmm0
ff
addss  -0x98(%rbp),%xmm0
ff
addss  -0x9c(%rbp),%xmm0
ff
addss  -0xa0(%rbp),%xmm0
ff
addss  -0xa4(%rbp),%xmm0
ff
addss  -0xa8(%rbp),%xmm0
ff
addss  -0xac(%rbp),%xmm0
ff
addss  -0xb0(%rbp),%xmm0
ff
addss  -0xb4(%rbp),%xmm0
ff
addss  -0xb8(%rbp),%xmm0
ff
addss  -0xbc(%rbp),%xmm0
ff
addss  -0xc0(%rbp),%xmm0
ff
addss  -0xc4(%rbp),%xmm0
ff
addss  -0xc8(%rbp),%xmm0
ff
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<load_store_sf>:
xorps  %xmm0,%xmm0
test   %rdi,%rdi
je     1db1 <load_store_sf+0xcb1>
movss  %xmm0,-0x4(%rsp)
xor    %r9d,%r9d
xorps  %xmm0,%xmm0
movss  %xmm0,-0x8(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0xc(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x10(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x14(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x18(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x1c(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x20(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x24(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x28(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x2c(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x30(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x34(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x38(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rsp)
xorps  %xmm4,%xmm4
xorps  %xmm5,%xmm5
xorps  %xmm6,%xmm6
xorps  %xmm7,%xmm7
xorps  %xmm1,%xmm1
xorps  %xmm8,%xmm8
xorps  %xmm9,%xmm9
xorps  %xmm10,%xmm10
xorps  %xmm11,%xmm11
xorps  %xmm12,%xmm12
xorps  %xmm13,%xmm13
xorps  %xmm14,%xmm14
xorps  %xmm15,%xmm15
xorps  %xmm2,%xmm2
xorps  %xmm0,%xmm0
jmp    123e <load_store_sf+0x13e>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x10,%r9
add    $0xffffffffffffffff,%rdi
je     1cdb <load_store_sf+0xbdb>
mov    (%rcx,%r9,1),%rax
test   $0x1,%al
jne    15d0 <load_store_sf+0x4d0>
test   $0x2,%al
jne    15e0 <load_store_sf+0x4e0>
test   $0x4,%al
jne    15f0 <load_store_sf+0x4f0>
test   $0x8,%al
jne    1601 <load_store_sf+0x501>
test   $0x10,%al
jne    1612 <load_store_sf+0x512>
test   $0x20,%al
jne    1623 <load_store_sf+0x523>
test   $0x40,%al
jne    1634 <load_store_sf+0x534>
test   $0x80,%al
jne    1645 <load_store_sf+0x545>
test   $0x100,%eax
jne    1659 <load_store_sf+0x559>
test   $0x200,%eax
je     129d <load_store_sf+0x19d>
movss  (%rsi),%xmm8
add    $0x4,%rsi
mov    0x8(%rcx,%r9,1),%r10
test   $0x400,%eax
jne    1680 <load_store_sf+0x580>
test   $0x800,%eax
jne    1693 <load_store_sf+0x593>
test   $0x1000,%eax
jne    16a6 <load_store_sf+0x5a6>
test   $0x2000,%eax
jne    16b9 <load_store_sf+0x5b9>
test   $0x4000,%eax
jne    16cc <load_store_sf+0x5cc>
test   $0x8000,%eax
jne    16df <load_store_sf+0x5df>
test   $0x10000,%eax
jne    16f8 <load_store_sf+0x5f8>
test   $0x20000,%eax
jne    1711 <load_store_sf+0x611>
test   $0x40000,%eax
jne    172a <load_store_sf+0x62a>
test   $0x80000,%eax
jne    1743 <load_store_sf+0x643>
test   $0x1,%r10b
jne    175b <load_store_sf+0x65b>
test   $0x2,%r10b
jne    1773 <load_store_sf+0x673>
test   $0x4,%r10b
jne    178b <load_store_sf+0x68b>
test   $0x8,%r10b
jne    17a3 <load_store_sf+0x6a3>
test   $0x10,%r10b
jne    17bb <load_store_sf+0x6bb>
test   $0x20,%r10b
jne    17d3 <load_store_sf+0x6d3>
test   $0x40,%r10b
jne    17eb <load_store_sf+0x6eb>
test   $0x80,%r10b
jne    1803 <load_store_sf+0x703>
test   $0x100,%r10d
jne    181e <load_store_sf+0x71e>
test   $0x200,%r10d
jne    1839 <load_store_sf+0x739>
test   $0x400,%r10d
jne    1854 <load_store_sf+0x754>
test   $0x800,%r10d
jne    186f <load_store_sf+0x76f>
test   $0x1000,%r10d
jne    188a <load_store_sf+0x78a>
test   $0x2000,%r10d
jne    18a5 <load_store_sf+0x7a5>
test   $0x4000,%r10d
jne    18c0 <load_store_sf+0x7c0>
test   $0x8000,%r10d
jne    18db <load_store_sf+0x7db>
test   $0x10000,%r10d
jne    18f6 <load_store_sf+0x7f6>
test   $0x20000,%r10d
jne    1911 <load_store_sf+0x811>
test   $0x40000,%r10d
jne    192c <load_store_sf+0x82c>
test   $0x80000,%r10d
je     1406 <load_store_sf+0x306>
movss  (%rsi),%xmm3
movss  %xmm3,-0x4(%rsp)
add    $0x4,%rsi
mov    (%r8,%r9,1),%rax
mov    0x8(%r8,%r9,1),%r10
test   $0x1,%al
jne    1950 <load_store_sf+0x850>
test   $0x2,%al
jne    1960 <load_store_sf+0x860>
test   $0x4,%al
jne    1970 <load_store_sf+0x870>
test   $0x8,%al
jne    1981 <load_store_sf+0x881>
test   $0x10,%al
jne    1992 <load_store_sf+0x892>
test   $0x20,%al
jne    19a3 <load_store_sf+0x8a3>
test   $0x40,%al
jne    19b4 <load_store_sf+0x8b4>
test   $0x80,%al
jne    19c5 <load_store_sf+0x8c5>
test   $0x100,%eax
jne    19d9 <load_store_sf+0x8d9>
test   $0x200,%eax
jne    19ed <load_store_sf+0x8ed>
test   $0x400,%eax
jne    1a01 <load_store_sf+0x901>
test   $0x800,%eax
jne    1a14 <load_store_sf+0x914>
test   $0x1000,%eax
jne    1a27 <load_store_sf+0x927>
test   $0x2000,%eax
jne    1a3a <load_store_sf+0x93a>
test   $0x4000,%eax
jne    1a4d <load_store_sf+0x94d>
test   $0x8000,%eax
jne    1a60 <load_store_sf+0x960>
test   $0x10000,%eax
jne    1a79 <load_store_sf+0x979>
test   $0x20000,%eax
jne    1a92 <load_store_sf+0x992>
test   $0x40000,%eax
jne    1aab <load_store_sf+0x9ab>
test   $0x80000,%eax
jne    1ac4 <load_store_sf+0x9c4>
test   $0x1,%r10b
jne    1adc <load_store_sf+0x9dc>
test   $0x2,%r10b
jne    1af4 <load_store_sf+0x9f4>
test   $0x4,%r10b
jne    1b0c <load_store_sf+0xa0c>
test   $0x8,%r10b
jne    1b24 <load_store_sf+0xa24>
test   $0x10,%r10b
jne    1b3c <load_store_sf+0xa3c>
test   $0x20,%r10b
jne    1b54 <load_store_sf+0xa54>
test   $0x40,%r10b
jne    1b6c <load_store_sf+0xa6c>
test   $0x80,%r10b
jne    1b84 <load_store_sf+0xa84>
test   $0x100,%r10d
jne    1b9f <load_store_sf+0xa9f>
test   $0x200,%r10d
jne    1bba <load_store_sf+0xaba>
test   $0x400,%r10d
jne    1bd5 <load_store_sf+0xad5>
test   $0x800,%r10d
jne    1bf0 <load_store_sf+0xaf0>
test   $0x1000,%r10d
jne    1c0b <load_store_sf+0xb0b>
test   $0x2000,%r10d
jne    1c26 <load_store_sf+0xb26>
test   $0x4000,%r10d
jne    1c41 <load_store_sf+0xb41>
test   $0x8000,%r10d
jne    1c5c <load_store_sf+0xb5c>
test   $0x10000,%r10d
jne    1c77 <load_store_sf+0xb77>
test   $0x20000,%r10d
jne    1c92 <load_store_sf+0xb92>
test   $0x40000,%r10d
jne    1cad <load_store_sf+0xbad>
test   $0x80000,%r10d
je     1230 <load_store_sf+0x130>
jmp    1cc8 <load_store_sf+0xbc8>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rsi),%xmm0
add    $0x4,%rsi
test   $0x2,%al
je     1252 <load_store_sf+0x152>
movss  (%rsi),%xmm2
add    $0x4,%rsi
test   $0x4,%al
je     125a <load_store_sf+0x15a>
movss  (%rsi),%xmm15
add    $0x4,%rsi
test   $0x8,%al
je     1262 <load_store_sf+0x162>
movss  (%rsi),%xmm14
add    $0x4,%rsi
test   $0x10,%al
je     126a <load_store_sf+0x16a>
movss  (%rsi),%xmm13
add    $0x4,%rsi
test   $0x20,%al
je     1272 <load_store_sf+0x172>
movss  (%rsi),%xmm12
add    $0x4,%rsi
test   $0x40,%al
je     127a <load_store_sf+0x17a>
movss  (%rsi),%xmm11
add    $0x4,%rsi
test   $0x80,%al
je     1282 <load_store_sf+0x182>
movss  (%rsi),%xmm10
add    $0x4,%rsi
test   $0x100,%eax
je     128d <load_store_sf+0x18d>
movss  (%rsi),%xmm9
add    $0x4,%rsi
test   $0x200,%eax
jne    1294 <load_store_sf+0x194>
jmp    129d <load_store_sf+0x19d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rsi),%xmm1
add    $0x4,%rsi
test   $0x800,%eax
je     12b8 <load_store_sf+0x1b8>
movss  (%rsi),%xmm7
add    $0x4,%rsi
test   $0x1000,%eax
je     12c3 <load_store_sf+0x1c3>
movss  (%rsi),%xmm6
add    $0x4,%rsi
test   $0x2000,%eax
je     12ce <load_store_sf+0x1ce>
movss  (%rsi),%xmm5
add    $0x4,%rsi
test   $0x4000,%eax
je     12d9 <load_store_sf+0x1d9>
movss  (%rsi),%xmm4
add    $0x4,%rsi
test   $0x8000,%eax
je     12e4 <load_store_sf+0x1e4>
movss  (%rsi),%xmm3
movss  %xmm3,-0x64(%rsp)
add    $0x4,%rsi
test   $0x10000,%eax
je     12ef <load_store_sf+0x1ef>
movss  (%rsi),%xmm3
movss  %xmm3,-0x60(%rsp)
add    $0x4,%rsi
test   $0x20000,%eax
je     12fa <load_store_sf+0x1fa>
movss  (%rsi),%xmm3
movss  %xmm3,-0x5c(%rsp)
add    $0x4,%rsi
test   $0x40000,%eax
je     1305 <load_store_sf+0x205>
movss  (%rsi),%xmm3
movss  %xmm3,-0x58(%rsp)
add    $0x4,%rsi
test   $0x80000,%eax
je     1310 <load_store_sf+0x210>
movss  (%rsi),%xmm3
movss  %xmm3,-0x54(%rsp)
add    $0x4,%rsi
test   $0x1,%r10b
je     131a <load_store_sf+0x21a>
movss  (%rsi),%xmm3
movss  %xmm3,-0x50(%rsp)
add    $0x4,%rsi
test   $0x2,%r10b
je     1324 <load_store_sf+0x224>
movss  (%rsi),%xmm3
movss  %xmm3,-0x4c(%rsp)
add    $0x4,%rsi
test   $0x4,%r10b
je     132e <load_store_sf+0x22e>
movss  (%rsi),%xmm3
movss  %xmm3,-0x48(%rsp)
add    $0x4,%rsi
test   $0x8,%r10b
je     1338 <load_store_sf+0x238>
movss  (%rsi),%xmm3
movss  %xmm3,-0x44(%rsp)
add    $0x4,%rsi
test   $0x10,%r10b
je     1342 <load_store_sf+0x242>
movss  (%rsi),%xmm3
movss  %xmm3,-0x40(%rsp)
add    $0x4,%rsi
test   $0x20,%r10b
je     134c <load_store_sf+0x24c>
movss  (%rsi),%xmm3
movss  %xmm3,-0x3c(%rsp)
add    $0x4,%rsi
test   $0x40,%r10b
je     1356 <load_store_sf+0x256>
movss  (%rsi),%xmm3
movss  %xmm3,-0x38(%rsp)
add    $0x4,%rsi
test   $0x80,%r10b
je     1360 <load_store_sf+0x260>
movss  (%rsi),%xmm3
movss  %xmm3,-0x34(%rsp)
add    $0x4,%rsi
test   $0x100,%r10d
je     136d <load_store_sf+0x26d>
movss  (%rsi),%xmm3
movss  %xmm3,-0x30(%rsp)
add    $0x4,%rsi
test   $0x200,%r10d
je     137a <load_store_sf+0x27a>
movss  (%rsi),%xmm3
movss  %xmm3,-0x2c(%rsp)
add    $0x4,%rsi
test   $0x400,%r10d
je     1387 <load_store_sf+0x287>
movss  (%rsi),%xmm3
movss  %xmm3,-0x28(%rsp)
add    $0x4,%rsi
test   $0x800,%r10d
je     1394 <load_store_sf+0x294>
movss  (%rsi),%xmm3
movss  %xmm3,-0x24(%rsp)
add    $0x4,%rsi
test   $0x1000,%r10d
je     13a1 <load_store_sf+0x2a1>
movss  (%rsi),%xmm3
movss  %xmm3,-0x20(%rsp)
add    $0x4,%rsi
test   $0x2000,%r10d
je     13ae <load_store_sf+0x2ae>
movss  (%rsi),%xmm3
movss  %xmm3,-0x1c(%rsp)
add    $0x4,%rsi
test   $0x4000,%r10d
je     13bb <load_store_sf+0x2bb>
movss  (%rsi),%xmm3
movss  %xmm3,-0x18(%rsp)
add    $0x4,%rsi
test   $0x8000,%r10d
je     13c8 <load_store_sf+0x2c8>
movss  (%rsi),%xmm3
movss  %xmm3,-0x14(%rsp)
add    $0x4,%rsi
test   $0x10000,%r10d
je     13d5 <load_store_sf+0x2d5>
movss  (%rsi),%xmm3
movss  %xmm3,-0x10(%rsp)
add    $0x4,%rsi
test   $0x20000,%r10d
je     13e2 <load_store_sf+0x2e2>
movss  (%rsi),%xmm3
movss  %xmm3,-0xc(%rsp)
add    $0x4,%rsi
test   $0x40000,%r10d
je     13ef <load_store_sf+0x2ef>
movss  (%rsi),%xmm3
movss  %xmm3,-0x8(%rsp)
add    $0x4,%rsi
test   $0x80000,%r10d
jne    13f8 <load_store_sf+0x2f8>
jmp    1406 <load_store_sf+0x306>
nopl   0x0(%rax)
movss  %xmm0,(%rdx)
add    $0x4,%rdx
test   $0x2,%al
je     141f <load_store_sf+0x31f>
movss  %xmm2,(%rdx)
add    $0x4,%rdx
test   $0x4,%al
je     1427 <load_store_sf+0x327>
movss  %xmm15,(%rdx)
add    $0x4,%rdx
test   $0x8,%al
je     142f <load_store_sf+0x32f>
movss  %xmm14,(%rdx)
add    $0x4,%rdx
test   $0x10,%al
je     1437 <load_store_sf+0x337>
movss  %xmm13,(%rdx)
add    $0x4,%rdx
test   $0x20,%al
je     143f <load_store_sf+0x33f>
movss  %xmm12,(%rdx)
add    $0x4,%rdx
test   $0x40,%al
je     1447 <load_store_sf+0x347>
movss  %xmm11,(%rdx)
add    $0x4,%rdx
test   $0x80,%al
je     144f <load_store_sf+0x34f>
movss  %xmm10,(%rdx)
add    $0x4,%rdx
test   $0x100,%eax
je     145a <load_store_sf+0x35a>
movss  %xmm9,(%rdx)
add    $0x4,%rdx
test   $0x200,%eax
je     1465 <load_store_sf+0x365>
movss  %xmm8,(%rdx)
add    $0x4,%rdx
test   $0x400,%eax
je     1470 <load_store_sf+0x370>
movss  %xmm1,(%rdx)
add    $0x4,%rdx
test   $0x800,%eax
je     147b <load_store_sf+0x37b>
movss  %xmm7,(%rdx)
add    $0x4,%rdx
test   $0x1000,%eax
je     1486 <load_store_sf+0x386>
movss  %xmm6,(%rdx)
add    $0x4,%rdx
test   $0x2000,%eax
je     1491 <load_store_sf+0x391>
movss  %xmm5,(%rdx)
add    $0x4,%rdx
test   $0x4000,%eax
je     149c <load_store_sf+0x39c>
movss  %xmm4,(%rdx)
add    $0x4,%rdx
test   $0x8000,%eax
je     14a7 <load_store_sf+0x3a7>
movss  -0x64(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x10000,%eax
je     14b2 <load_store_sf+0x3b2>
movss  -0x60(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x20000,%eax
je     14bd <load_store_sf+0x3bd>
movss  -0x5c(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x40000,%eax
je     14c8 <load_store_sf+0x3c8>
movss  -0x58(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x80000,%eax
je     14d3 <load_store_sf+0x3d3>
movss  -0x54(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x1,%r10b
je     14dd <load_store_sf+0x3dd>
movss  -0x50(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x2,%r10b
je     14e7 <load_store_sf+0x3e7>
movss  -0x4c(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x4,%r10b
je     14f1 <load_store_sf+0x3f1>
movss  -0x48(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x8,%r10b
je     14fb <load_store_sf+0x3fb>
movss  -0x44(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x10,%r10b
je     1505 <load_store_sf+0x405>
movss  -0x40(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x20,%r10b
je     150f <load_store_sf+0x40f>
movss  -0x3c(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x40,%r10b
je     1519 <load_store_sf+0x419>
movss  -0x38(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x80,%r10b
je     1523 <load_store_sf+0x423>
movss  -0x34(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x100,%r10d
je     1530 <load_store_sf+0x430>
movss  -0x30(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x200,%r10d
je     153d <load_store_sf+0x43d>
movss  -0x2c(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x400,%r10d
je     154a <load_store_sf+0x44a>
movss  -0x28(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x800,%r10d
je     1557 <load_store_sf+0x457>
movss  -0x24(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x1000,%r10d
je     1564 <load_store_sf+0x464>
movss  -0x20(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x2000,%r10d
je     1571 <load_store_sf+0x471>
movss  -0x1c(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x4000,%r10d
je     157e <load_store_sf+0x47e>
movss  -0x18(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x8000,%r10d
je     158b <load_store_sf+0x48b>
movss  -0x14(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x10000,%r10d
je     1598 <load_store_sf+0x498>
movss  -0x10(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x20000,%r10d
je     15a5 <load_store_sf+0x4a5>
movss  -0xc(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x40000,%r10d
je     15b2 <load_store_sf+0x4b2>
movss  -0x8(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x80000,%r10d
je     1230 <load_store_sf+0x130>
movss  -0x4(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
jmp    1230 <load_store_sf+0x130>
addss  %xmm2,%xmm0
addss  %xmm15,%xmm0
addss  %xmm14,%xmm0
addss  %xmm13,%xmm0
addss  %xmm12,%xmm0
addss  %xmm11,%xmm0
addss  %xmm10,%xmm0
addss  %xmm9,%xmm0
addss  %xmm8,%xmm0
addss  %xmm1,%xmm0
addss  %xmm7,%xmm0
addss  %xmm6,%xmm0
addss  %xmm5,%xmm0
addss  %xmm4,%xmm0
addss  -0x64(%rsp),%xmm0
addss  -0x60(%rsp),%xmm0
addss  -0x5c(%rsp),%xmm0
addss  -0x58(%rsp),%xmm0
addss  -0x54(%rsp),%xmm0
addss  -0x50(%rsp),%xmm0
addss  -0x4c(%rsp),%xmm0
addss  -0x48(%rsp),%xmm0
addss  -0x44(%rsp),%xmm0
addss  -0x40(%rsp),%xmm0
addss  -0x3c(%rsp),%xmm0
addss  -0x38(%rsp),%xmm0
addss  -0x34(%rsp),%xmm0
addss  -0x30(%rsp),%xmm0
addss  -0x2c(%rsp),%xmm0
addss  -0x28(%rsp),%xmm0
addss  -0x24(%rsp),%xmm0
addss  -0x20(%rsp),%xmm0
addss  -0x1c(%rsp),%xmm0
addss  -0x18(%rsp),%xmm0
addss  -0x14(%rsp),%xmm0
addss  -0x10(%rsp),%xmm0
addss  -0xc(%rsp),%xmm0
addss  -0x8(%rsp),%xmm0
addss  -0x4(%rsp),%xmm0
ret

LLVM IR (-O0):
define float @load_store_sf(i64 %0, float* %1, float* %2, i64* %3, i64* %4) {
%6 = alloca i64
%7 = alloca float*
%8 = alloca float*
%9 = alloca i64*
%10 = alloca i64*
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca float
%26 = alloca float
%27 = alloca float
%28 = alloca float
%29 = alloca float
%30 = alloca float
%31 = alloca float
%32 = alloca float
%33 = alloca float
%34 = alloca float
%35 = alloca float
%36 = alloca float
%37 = alloca float
%38 = alloca float
%39 = alloca float
%40 = alloca float
%41 = alloca float
%42 = alloca float
%43 = alloca float
%44 = alloca float
%45 = alloca float
%46 = alloca float
%47 = alloca float
%48 = alloca float
%49 = alloca float
%50 = alloca float
%51 = alloca i64
%52 = alloca i64
%53 = alloca i64
%54 = alloca i64
%55 = alloca i64
store i64 %0, i64* %6
store float* %1, float** %7
store float* %2, float** %8
store i64* %3, i64** %9
store i64* %4, i64** %10
store float 0.000000e+00, float* %11
store float 0.000000e+00, float* %12
store float 0.000000e+00, float* %13
store float 0.000000e+00, float* %14
store float 0.000000e+00, float* %15
store float 0.000000e+00, float* %16
store float 0.000000e+00, float* %17
store float 0.000000e+00, float* %18
store float 0.000000e+00, float* %19
store float 0.000000e+00, float* %20
store float 0.000000e+00, float* %21
store float 0.000000e+00, float* %22
store float 0.000000e+00, float* %23
store float 0.000000e+00, float* %24
store float 0.000000e+00, float* %25
store float 0.000000e+00, float* %26
store float 0.000000e+00, float* %27
store float 0.000000e+00, float* %28
store float 0.000000e+00, float* %29
store float 0.000000e+00, float* %30
store float 0.000000e+00, float* %31
store float 0.000000e+00, float* %32
store float 0.000000e+00, float* %33
store float 0.000000e+00, float* %34
store float 0.000000e+00, float* %35
store float 0.000000e+00, float* %36
store float 0.000000e+00, float* %37
store float 0.000000e+00, float* %38
store float 0.000000e+00, float* %39
store float 0.000000e+00, float* %40
store float 0.000000e+00, float* %41
store float 0.000000e+00, float* %42
store float 0.000000e+00, float* %43
store float 0.000000e+00, float* %44
store float 0.000000e+00, float* %45
store float 0.000000e+00, float* %46
store float 0.000000e+00, float* %47
store float 0.000000e+00, float* %48
store float 0.000000e+00, float* %49
store float 0.000000e+00, float* %50
store i64 0, i64* %55
br label %56
56: ; preds = %713, %5
%57 = load i64, i64* %55
%58 = load i64, i64* %6
%59 = icmp ult i64 %57, %58
br i1 %59, label %60, label %716
60: ; preds = %56
%61 = load i64*, i64** %9
%62 = getelementptr inbounds i64, i64* %61, i32 1
store i64* %62, i64** %9
%63 = load i64, i64* %61
store i64 %63, i64* %51
%64 = load i64*, i64** %9
%65 = getelementptr inbounds i64, i64* %64, i32 1
store i64* %65, i64** %9
%66 = load i64, i64* %64
store i64 %66, i64* %52
%67 = load i64, i64* %51
%68 = and i64 %67, 1
%69 = icmp ne i64 %68, 0
br i1 %69, label %70, label %74
70: ; preds = %60
%71 = load float*, float** %7
%72 = getelementptr inbounds float, float* %71, i32 1
store float* %72, float** %7
%73 = load float, float* %71
store float %73, float* %11
br label %74
74: ; preds = %70, %60
%75 = load i64, i64* %51
%76 = and i64 %75, 2
%77 = icmp ne i64 %76, 0
br i1 %77, label %78, label %82
78: ; preds = %74
%79 = load float*, float** %7
%80 = getelementptr inbounds float, float* %79, i32 1
store float* %80, float** %7
%81 = load float, float* %79
store float %81, float* %12
br label %82
82: ; preds = %78, %74
%83 = load i64, i64* %51
%84 = and i64 %83, 4
%85 = icmp ne i64 %84, 0
br i1 %85, label %86, label %90
86: ; preds = %82
%87 = load float*, float** %7
%88 = getelementptr inbounds float, float* %87, i32 1
store float* %88, float** %7
%89 = load float, float* %87
store float %89, float* %13
br label %90
90: ; preds = %86, %82
%91 = load i64, i64* %51
%92 = and i64 %91, 8
%93 = icmp ne i64 %92, 0
br i1 %93, label %94, label %98
94: ; preds = %90
%95 = load float*, float** %7
%96 = getelementptr inbounds float, float* %95, i32 1
store float* %96, float** %7
%97 = load float, float* %95
store float %97, float* %14
br label %98
98: ; preds = %94, %90
%99 = load i64, i64* %51
%100 = and i64 %99, 16
%101 = icmp ne i64 %100, 0
br i1 %101, label %102, label %106
102: ; preds = %98
%103 = load float*, float** %7
%104 = getelementptr inbounds float, float* %103, i32 1
store float* %104, float** %7
%105 = load float, float* %103
store float %105, float* %15
br label %106
106: ; preds = %102, %98
%107 = load i64, i64* %51
%108 = and i64 %107, 32
%109 = icmp ne i64 %108, 0
br i1 %109, label %110, label %114
110: ; preds = %106
%111 = load float*, float** %7
%112 = getelementptr inbounds float, float* %111, i32 1
store float* %112, float** %7
%113 = load float, float* %111
store float %113, float* %16
br label %114
114: ; preds = %110, %106
%115 = load i64, i64* %51
%116 = and i64 %115, 64
%117 = icmp ne i64 %116, 0
br i1 %117, label %118, label %122
118: ; preds = %114
%119 = load float*, float** %7
%120 = getelementptr inbounds float, float* %119, i32 1
store float* %120, float** %7
%121 = load float, float* %119
store float %121, float* %17
br label %122
122: ; preds = %118, %114
%123 = load i64, i64* %51
%124 = and i64 %123, 128
%125 = icmp ne i64 %124, 0
br i1 %125, label %126, label %130
126: ; preds = %122
%127 = load float*, float** %7
%128 = getelementptr inbounds float, float* %127, i32 1
store float* %128, float** %7
%129 = load float, float* %127
store float %129, float* %18
br label %130
130: ; preds = %126, %122
%131 = load i64, i64* %51
%132 = and i64 %131, 256
%133 = icmp ne i64 %132, 0
br i1 %133, label %134, label %138
134: ; preds = %130
%135 = load float*, float** %7
%136 = getelementptr inbounds float, float* %135, i32 1
store float* %136, float** %7
%137 = load float, float* %135
store float %137, float* %19
br label %138
138: ; preds = %134, %130
%139 = load i64, i64* %51
%140 = and i64 %139, 512
%141 = icmp ne i64 %140, 0
br i1 %141, label %142, label %146
142: ; preds = %138
%143 = load float*, float** %7
%144 = getelementptr inbounds float, float* %143, i32 1
store float* %144, float** %7
%145 = load float, float* %143
store float %145, float* %20
br label %146
146: ; preds = %142, %138
%147 = load i64, i64* %51
%148 = and i64 %147, 1024
%149 = icmp ne i64 %148, 0
br i1 %149, label %150, label %154
150: ; preds = %146
%151 = load float*, float** %7
%152 = getelementptr inbounds float, float* %151, i32 1
store float* %152, float** %7
%153 = load float, float* %151
store float %153, float* %21
br label %154
154: ; preds = %150, %146
%155 = load i64, i64* %51
%156 = and i64 %155, 2048
%157 = icmp ne i64 %156, 0
br i1 %157, label %158, label %162
158: ; preds = %154
%159 = load float*, float** %7
%160 = getelementptr inbounds float, float* %159, i32 1
store float* %160, float** %7
%161 = load float, float* %159
store float %161, float* %22
br label %162
162: ; preds = %158, %154
%163 = load i64, i64* %51
%164 = and i64 %163, 4096
%165 = icmp ne i64 %164, 0
br i1 %165, label %166, label %170
166: ; preds = %162
%167 = load float*, float** %7
%168 = getelementptr inbounds float, float* %167, i32 1
store float* %168, float** %7
%169 = load float, float* %167
store float %169, float* %23
br label %170
170: ; preds = %166, %162
%171 = load i64, i64* %51
%172 = and i64 %171, 8192
%173 = icmp ne i64 %172, 0
br i1 %173, label %174, label %178
174: ; preds = %170
%175 = load float*, float** %7
%176 = getelementptr inbounds float, float* %175, i32 1
store float* %176, float** %7
%177 = load float, float* %175
store float %177, float* %24
br label %178
178: ; preds = %174, %170
%179 = load i64, i64* %51
%180 = and i64 %179, 16384
%181 = icmp ne i64 %180, 0
br i1 %181, label %182, label %186
182: ; preds = %178
%183 = load float*, float** %7
%184 = getelementptr inbounds float, float* %183, i32 1
store float* %184, float** %7
%185 = load float, float* %183
store float %185, float* %25
br label %186
186: ; preds = %182, %178
%187 = load i64, i64* %51
%188 = and i64 %187, 32768
%189 = icmp ne i64 %188, 0
br i1 %189, label %190, label %194
190: ; preds = %186
%191 = load float*, float** %7
%192 = getelementptr inbounds float, float* %191, i32 1
store float* %192, float** %7
%193 = load float, float* %191
store float %193, float* %26
br label %194
194: ; preds = %190, %186
%195 = load i64, i64* %51
%196 = and i64 %195, 65536
%197 = icmp ne i64 %196, 0
br i1 %197, label %198, label %202
198: ; preds = %194
%199 = load float*, float** %7
%200 = getelementptr inbounds float, float* %199, i32 1
store float* %200, float** %7
%201 = load float, float* %199
store float %201, float* %27
br label %202
202: ; preds = %198, %194
%203 = load i64, i64* %51
%204 = and i64 %203, 131072
%205 = icmp ne i64 %204, 0
br i1 %205, label %206, label %210
206: ; preds = %202
%207 = load float*, float** %7
%208 = getelementptr inbounds float, float* %207, i32 1
store float* %208, float** %7
%209 = load float, float* %207
store float %209, float* %28
br label %210
210: ; preds = %206, %202
%211 = load i64, i64* %51
%212 = and i64 %211, 262144
%213 = icmp ne i64 %212, 0
br i1 %213, label %214, label %218
214: ; preds = %210
%215 = load float*, float** %7
%216 = getelementptr inbounds float, float* %215, i32 1
store float* %216, float** %7
%217 = load float, float* %215
store float %217, float* %29
br label %218
218: ; preds = %214, %210
%219 = load i64, i64* %51
%220 = and i64 %219, 524288
%221 = icmp ne i64 %220, 0
br i1 %221, label %222, label %226
222: ; preds = %218
%223 = load float*, float** %7
%224 = getelementptr inbounds float, float* %223, i32 1
store float* %224, float** %7
%225 = load float, float* %223
store float %225, float* %30
br label %226
226: ; preds = %222, %218
%227 = load i64, i64* %52
%228 = and i64 %227, 1
%229 = icmp ne i64 %228, 0
br i1 %229, label %230, label %234
230: ; preds = %226
%231 = load float*, float** %7
%232 = getelementptr inbounds float, float* %231, i32 1
store float* %232, float** %7
%233 = load float, float* %231
store float %233, float* %31
br label %234
234: ; preds = %230, %226
%235 = load i64, i64* %52
%236 = and i64 %235, 2
%237 = icmp ne i64 %236, 0
br i1 %237, label %238, label %242
238: ; preds = %234
%239 = load float*, float** %7
%240 = getelementptr inbounds float, float* %239, i32 1
store float* %240, float** %7
%241 = load float, float* %239
store float %241, float* %32
br label %242
242: ; preds = %238, %234
%243 = load i64, i64* %52
%244 = and i64 %243, 4
%245 = icmp ne i64 %244, 0
br i1 %245, label %246, label %250
246: ; preds = %242
%247 = load float*, float** %7
%248 = getelementptr inbounds float, float* %247, i32 1
store float* %248, float** %7
%249 = load float, float* %247
store float %249, float* %33
br label %250
250: ; preds = %246, %242
%251 = load i64, i64* %52
%252 = and i64 %251, 8
%253 = icmp ne i64 %252, 0
br i1 %253, label %254, label %258
254: ; preds = %250
%255 = load float*, float** %7
%256 = getelementptr inbounds float, float* %255, i32 1
store float* %256, float** %7
%257 = load float, float* %255
store float %257, float* %34
br label %258
258: ; preds = %254, %250
%259 = load i64, i64* %52
%260 = and i64 %259, 16
%261 = icmp ne i64 %260, 0
br i1 %261, label %262, label %266
262: ; preds = %258
%263 = load float*, float** %7
%264 = getelementptr inbounds float, float* %263, i32 1
store float* %264, float** %7
%265 = load float, float* %263
store float %265, float* %35
br label %266
266: ; preds = %262, %258
%267 = load i64, i64* %52
%268 = and i64 %267, 32
%269 = icmp ne i64 %268, 0
br i1 %269, label %270, label %274
270: ; preds = %266
%271 = load float*, float** %7
%272 = getelementptr inbounds float, float* %271, i32 1
store float* %272, float** %7
%273 = load float, float* %271
store float %273, float* %36
br label %274
274: ; preds = %270, %266
%275 = load i64, i64* %52
%276 = and i64 %275, 64
%277 = icmp ne i64 %276, 0
br i1 %277, label %278, label %282
278: ; preds = %274
%279 = load float*, float** %7
%280 = getelementptr inbounds float, float* %279, i32 1
store float* %280, float** %7
%281 = load float, float* %279
store float %281, float* %37
br label %282
282: ; preds = %278, %274
%283 = load i64, i64* %52
%284 = and i64 %283, 128
%285 = icmp ne i64 %284, 0
br i1 %285, label %286, label %290
286: ; preds = %282
%287 = load float*, float** %7
%288 = getelementptr inbounds float, float* %287, i32 1
store float* %288, float** %7
%289 = load float, float* %287
store float %289, float* %38
br label %290
290: ; preds = %286, %282
%291 = load i64, i64* %52
%292 = and i64 %291, 256
%293 = icmp ne i64 %292, 0
br i1 %293, label %294, label %298
294: ; preds = %290
%295 = load float*, float** %7
%296 = getelementptr inbounds float, float* %295, i32 1
store float* %296, float** %7
%297 = load float, float* %295
store float %297, float* %39
br label %298
298: ; preds = %294, %290
%299 = load i64, i64* %52
%300 = and i64 %299, 512
%301 = icmp ne i64 %300, 0
br i1 %301, label %302, label %306
302: ; preds = %298
%303 = load float*, float** %7
%304 = getelementptr inbounds float, float* %303, i32 1
store float* %304, float** %7
%305 = load float, float* %303
store float %305, float* %40
br label %306
306: ; preds = %302, %298
%307 = load i64, i64* %52
%308 = and i64 %307, 1024
%309 = icmp ne i64 %308, 0
br i1 %309, label %310, label %314
310: ; preds = %306
%311 = load float*, float** %7
%312 = getelementptr inbounds float, float* %311, i32 1
store float* %312, float** %7
%313 = load float, float* %311
store float %313, float* %41
br label %314
314: ; preds = %310, %306
%315 = load i64, i64* %52
%316 = and i64 %315, 2048
%317 = icmp ne i64 %316, 0
br i1 %317, label %318, label %322
318: ; preds = %314
%319 = load float*, float** %7
%320 = getelementptr inbounds float, float* %319, i32 1
store float* %320, float** %7
%321 = load float, float* %319
store float %321, float* %42
br label %322
322: ; preds = %318, %314
%323 = load i64, i64* %52
%324 = and i64 %323, 4096
%325 = icmp ne i64 %324, 0
br i1 %325, label %326, label %330
326: ; preds = %322
%327 = load float*, float** %7
%328 = getelementptr inbounds float, float* %327, i32 1
store float* %328, float** %7
%329 = load float, float* %327
store float %329, float* %43
br label %330
330: ; preds = %326, %322
%331 = load i64, i64* %52
%332 = and i64 %331, 8192
%333 = icmp ne i64 %332, 0
br i1 %333, label %334, label %338
334: ; preds = %330
%335 = load float*, float** %7
%336 = getelementptr inbounds float, float* %335, i32 1
store float* %336, float** %7
%337 = load float, float* %335
store float %337, float* %44
br label %338
338: ; preds = %334, %330
%339 = load i64, i64* %52
%340 = and i64 %339, 16384
%341 = icmp ne i64 %340, 0
br i1 %341, label %342, label %346
342: ; preds = %338
%343 = load float*, float** %7
%344 = getelementptr inbounds float, float* %343, i32 1
store float* %344, float** %7
%345 = load float, float* %343
store float %345, float* %45
br label %346
346: ; preds = %342, %338
%347 = load i64, i64* %52
%348 = and i64 %347, 32768
%349 = icmp ne i64 %348, 0
br i1 %349, label %350, label %354
350: ; preds = %346
%351 = load float*, float** %7
%352 = getelementptr inbounds float, float* %351, i32 1
store float* %352, float** %7
%353 = load float, float* %351
store float %353, float* %46
br label %354
354: ; preds = %350, %346
%355 = load i64, i64* %52
%356 = and i64 %355, 65536
%357 = icmp ne i64 %356, 0
br i1 %357, label %358, label %362
358: ; preds = %354
%359 = load float*, float** %7
%360 = getelementptr inbounds float, float* %359, i32 1
store float* %360, float** %7
%361 = load float, float* %359
store float %361, float* %47
br label %362
362: ; preds = %358, %354
%363 = load i64, i64* %52
%364 = and i64 %363, 131072
%365 = icmp ne i64 %364, 0
br i1 %365, label %366, label %370
366: ; preds = %362
%367 = load float*, float** %7
%368 = getelementptr inbounds float, float* %367, i32 1
store float* %368, float** %7
%369 = load float, float* %367
store float %369, float* %48
br label %370
370: ; preds = %366, %362
%371 = load i64, i64* %52
%372 = and i64 %371, 262144
%373 = icmp ne i64 %372, 0
br i1 %373, label %374, label %378
374: ; preds = %370
%375 = load float*, float** %7
%376 = getelementptr inbounds float, float* %375, i32 1
store float* %376, float** %7
%377 = load float, float* %375
store float %377, float* %49
br label %378
378: ; preds = %374, %370
%379 = load i64, i64* %52
%380 = and i64 %379, 524288
%381 = icmp ne i64 %380, 0
br i1 %381, label %382, label %386
382: ; preds = %378
%383 = load float*, float** %7
%384 = getelementptr inbounds float, float* %383, i32 1
store float* %384, float** %7
%385 = load float, float* %383
store float %385, float* %50
br label %386
386: ; preds = %382, %378
%387 = load i64*, i64** %10
%388 = getelementptr inbounds i64, i64* %387, i32 1
store i64* %388, i64** %10
%389 = load i64, i64* %387
store i64 %389, i64* %53
%390 = load i64*, i64** %10
%391 = getelementptr inbounds i64, i64* %390, i32 1
store i64* %391, i64** %10
%392 = load i64, i64* %390
store i64 %392, i64* %54
%393 = load i64, i64* %53
%394 = and i64 %393, 1
%395 = icmp ne i64 %394, 0
br i1 %395, label %396, label %400
396: ; preds = %386
%397 = load float, float* %11
%398 = load float*, float** %8
%399 = getelementptr inbounds float, float* %398, i32 1
store float* %399, float** %8
store float %397, float* %398
br label %400
400: ; preds = %396, %386
%401 = load i64, i64* %53
%402 = and i64 %401, 2
%403 = icmp ne i64 %402, 0
br i1 %403, label %404, label %408
404: ; preds = %400
%405 = load float, float* %12
%406 = load float*, float** %8
%407 = getelementptr inbounds float, float* %406, i32 1
store float* %407, float** %8
store float %405, float* %406
br label %408
408: ; preds = %404, %400
%409 = load i64, i64* %53
%410 = and i64 %409, 4
%411 = icmp ne i64 %410, 0
br i1 %411, label %412, label %416
412: ; preds = %408
%413 = load float, float* %13
%414 = load float*, float** %8
%415 = getelementptr inbounds float, float* %414, i32 1
store float* %415, float** %8
store float %413, float* %414
br label %416
416: ; preds = %412, %408
%417 = load i64, i64* %53
%418 = and i64 %417, 8
%419 = icmp ne i64 %418, 0
br i1 %419, label %420, label %424
420: ; preds = %416
%421 = load float, float* %14
%422 = load float*, float** %8
%423 = getelementptr inbounds float, float* %422, i32 1
store float* %423, float** %8
store float %421, float* %422
br label %424
424: ; preds = %420, %416
%425 = load i64, i64* %53
%426 = and i64 %425, 16
%427 = icmp ne i64 %426, 0
br i1 %427, label %428, label %432
428: ; preds = %424
%429 = load float, float* %15
%430 = load float*, float** %8
%431 = getelementptr inbounds float, float* %430, i32 1
store float* %431, float** %8
store float %429, float* %430
br label %432
432: ; preds = %428, %424
%433 = load i64, i64* %53
%434 = and i64 %433, 32
%435 = icmp ne i64 %434, 0
br i1 %435, label %436, label %440
436: ; preds = %432
%437 = load float, float* %16
%438 = load float*, float** %8
%439 = getelementptr inbounds float, float* %438, i32 1
store float* %439, float** %8
store float %437, float* %438
br label %440
440: ; preds = %436, %432
%441 = load i64, i64* %53
%442 = and i64 %441, 64
%443 = icmp ne i64 %442, 0
br i1 %443, label %444, label %448
444: ; preds = %440
%445 = load float, float* %17
%446 = load float*, float** %8
%447 = getelementptr inbounds float, float* %446, i32 1
store float* %447, float** %8
store float %445, float* %446
br label %448
448: ; preds = %444, %440
%449 = load i64, i64* %53
%450 = and i64 %449, 128
%451 = icmp ne i64 %450, 0
br i1 %451, label %452, label %456
452: ; preds = %448
%453 = load float, float* %18
%454 = load float*, float** %8
%455 = getelementptr inbounds float, float* %454, i32 1
store float* %455, float** %8
store float %453, float* %454
br label %456
456: ; preds = %452, %448
%457 = load i64, i64* %53
%458 = and i64 %457, 256
%459 = icmp ne i64 %458, 0
br i1 %459, label %460, label %464
460: ; preds = %456
%461 = load float, float* %19
%462 = load float*, float** %8
%463 = getelementptr inbounds float, float* %462, i32 1
store float* %463, float** %8
store float %461, float* %462
br label %464
464: ; preds = %460, %456
%465 = load i64, i64* %53
%466 = and i64 %465, 512
%467 = icmp ne i64 %466, 0
br i1 %467, label %468, label %472
468: ; preds = %464
%469 = load float, float* %20
%470 = load float*, float** %8
%471 = getelementptr inbounds float, float* %470, i32 1
store float* %471, float** %8
store float %469, float* %470
br label %472
472: ; preds = %468, %464
%473 = load i64, i64* %53
%474 = and i64 %473, 1024
%475 = icmp ne i64 %474, 0
br i1 %475, label %476, label %480
476: ; preds = %472
%477 = load float, float* %21
%478 = load float*, float** %8
%479 = getelementptr inbounds float, float* %478, i32 1
store float* %479, float** %8
store float %477, float* %478
br label %480
480: ; preds = %476, %472
%481 = load i64, i64* %53
%482 = and i64 %481, 2048
%483 = icmp ne i64 %482, 0
br i1 %483, label %484, label %488
484: ; preds = %480
%485 = load float, float* %22
%486 = load float*, float** %8
%487 = getelementptr inbounds float, float* %486, i32 1
store float* %487, float** %8
store float %485, float* %486
br label %488
488: ; preds = %484, %480
%489 = load i64, i64* %53
%490 = and i64 %489, 4096
%491 = icmp ne i64 %490, 0
br i1 %491, label %492, label %496
492: ; preds = %488
%493 = load float, float* %23
%494 = load float*, float** %8
%495 = getelementptr inbounds float, float* %494, i32 1
store float* %495, float** %8
store float %493, float* %494
br label %496
496: ; preds = %492, %488
%497 = load i64, i64* %53
%498 = and i64 %497, 8192
%499 = icmp ne i64 %498, 0
br i1 %499, label %500, label %504
500: ; preds = %496
%501 = load float, float* %24
%502 = load float*, float** %8
%503 = getelementptr inbounds float, float* %502, i32 1
store float* %503, float** %8
store float %501, float* %502
br label %504
504: ; preds = %500, %496
%505 = load i64, i64* %53
%506 = and i64 %505, 16384
%507 = icmp ne i64 %506, 0
br i1 %507, label %508, label %512
508: ; preds = %504
%509 = load float, float* %25
%510 = load float*, float** %8
%511 = getelementptr inbounds float, float* %510, i32 1
store float* %511, float** %8
store float %509, float* %510
br label %512
512: ; preds = %508, %504
%513 = load i64, i64* %53
%514 = and i64 %513, 32768
%515 = icmp ne i64 %514, 0
br i1 %515, label %516, label %520
516: ; preds = %512
%517 = load float, float* %26
%518 = load float*, float** %8
%519 = getelementptr inbounds float, float* %518, i32 1
store float* %519, float** %8
store float %517, float* %518
br label %520
520: ; preds = %516, %512
%521 = load i64, i64* %53
%522 = and i64 %521, 65536
%523 = icmp ne i64 %522, 0
br i1 %523, label %524, label %528
524: ; preds = %520
%525 = load float, float* %27
%526 = load float*, float** %8
%527 = getelementptr inbounds float, float* %526, i32 1
store float* %527, float** %8
store float %525, float* %526
br label %528
528: ; preds = %524, %520
%529 = load i64, i64* %53
%530 = and i64 %529, 131072
%531 = icmp ne i64 %530, 0
br i1 %531, label %532, label %536
532: ; preds = %528
%533 = load float, float* %28
%534 = load float*, float** %8
%535 = getelementptr inbounds float, float* %534, i32 1
store float* %535, float** %8
store float %533, float* %534
br label %536
536: ; preds = %532, %528
%537 = load i64, i64* %53
%538 = and i64 %537, 262144
%539 = icmp ne i64 %538, 0
br i1 %539, label %540, label %544
540: ; preds = %536
%541 = load float, float* %29
%542 = load float*, float** %8
%543 = getelementptr inbounds float, float* %542, i32 1
store float* %543, float** %8
store float %541, float* %542
br label %544
544: ; preds = %540, %536
%545 = load i64, i64* %53
%546 = and i64 %545, 524288
%547 = icmp ne i64 %546, 0
br i1 %547, label %548, label %552
548: ; preds = %544
%549 = load float, float* %30
%550 = load float*, float** %8
%551 = getelementptr inbounds float, float* %550, i32 1
store float* %551, float** %8
store float %549, float* %550
br label %552
552: ; preds = %548, %544
%553 = load i64, i64* %54
%554 = and i64 %553, 1
%555 = icmp ne i64 %554, 0
br i1 %555, label %556, label %560
556: ; preds = %552
%557 = load float, float* %31
%558 = load float*, float** %8
%559 = getelementptr inbounds float, float* %558, i32 1
store float* %559, float** %8
store float %557, float* %558
br label %560
560: ; preds = %556, %552
%561 = load i64, i64* %54
%562 = and i64 %561, 2
%563 = icmp ne i64 %562, 0
br i1 %563, label %564, label %568
564: ; preds = %560
%565 = load float, float* %32
%566 = load float*, float** %8
%567 = getelementptr inbounds float, float* %566, i32 1
store float* %567, float** %8
store float %565, float* %566
br label %568
568: ; preds = %564, %560
%569 = load i64, i64* %54
%570 = and i64 %569, 4
%571 = icmp ne i64 %570, 0
br i1 %571, label %572, label %576
572: ; preds = %568
%573 = load float, float* %33
%574 = load float*, float** %8
%575 = getelementptr inbounds float, float* %574, i32 1
store float* %575, float** %8
store float %573, float* %574
br label %576
576: ; preds = %572, %568
%577 = load i64, i64* %54
%578 = and i64 %577, 8
%579 = icmp ne i64 %578, 0
br i1 %579, label %580, label %584
580: ; preds = %576
%581 = load float, float* %34
%582 = load float*, float** %8
%583 = getelementptr inbounds float, float* %582, i32 1
store float* %583, float** %8
store float %581, float* %582
br label %584
584: ; preds = %580, %576
%585 = load i64, i64* %54
%586 = and i64 %585, 16
%587 = icmp ne i64 %586, 0
br i1 %587, label %588, label %592
588: ; preds = %584
%589 = load float, float* %35
%590 = load float*, float** %8
%591 = getelementptr inbounds float, float* %590, i32 1
store float* %591, float** %8
store float %589, float* %590
br label %592
592: ; preds = %588, %584
%593 = load i64, i64* %54
%594 = and i64 %593, 32
%595 = icmp ne i64 %594, 0
br i1 %595, label %596, label %600
596: ; preds = %592
%597 = load float, float* %36
%598 = load float*, float** %8
%599 = getelementptr inbounds float, float* %598, i32 1
store float* %599, float** %8
store float %597, float* %598
br label %600
600: ; preds = %596, %592
%601 = load i64, i64* %54
%602 = and i64 %601, 64
%603 = icmp ne i64 %602, 0
br i1 %603, label %604, label %608
604: ; preds = %600
%605 = load float, float* %37
%606 = load float*, float** %8
%607 = getelementptr inbounds float, float* %606, i32 1
store float* %607, float** %8
store float %605, float* %606
br label %608
608: ; preds = %604, %600
%609 = load i64, i64* %54
%610 = and i64 %609, 128
%611 = icmp ne i64 %610, 0
br i1 %611, label %612, label %616
612: ; preds = %608
%613 = load float, float* %38
%614 = load float*, float** %8
%615 = getelementptr inbounds float, float* %614, i32 1
store float* %615, float** %8
store float %613, float* %614
br label %616
616: ; preds = %612, %608
%617 = load i64, i64* %54
%618 = and i64 %617, 256
%619 = icmp ne i64 %618, 0
br i1 %619, label %620, label %624
620: ; preds = %616
%621 = load float, float* %39
%622 = load float*, float** %8
%623 = getelementptr inbounds float, float* %622, i32 1
store float* %623, float** %8
store float %621, float* %622
br label %624
624: ; preds = %620, %616
%625 = load i64, i64* %54
%626 = and i64 %625, 512
%627 = icmp ne i64 %626, 0
br i1 %627, label %628, label %632
628: ; preds = %624
%629 = load float, float* %40
%630 = load float*, float** %8
%631 = getelementptr inbounds float, float* %630, i32 1
store float* %631, float** %8
store float %629, float* %630
br label %632
632: ; preds = %628, %624
%633 = load i64, i64* %54
%634 = and i64 %633, 1024
%635 = icmp ne i64 %634, 0
br i1 %635, label %636, label %640
636: ; preds = %632
%637 = load float, float* %41
%638 = load float*, float** %8
%639 = getelementptr inbounds float, float* %638, i32 1
store float* %639, float** %8
store float %637, float* %638
br label %640
640: ; preds = %636, %632
%641 = load i64, i64* %54
%642 = and i64 %641, 2048
%643 = icmp ne i64 %642, 0
br i1 %643, label %644, label %648
644: ; preds = %640
%645 = load float, float* %42
%646 = load float*, float** %8
%647 = getelementptr inbounds float, float* %646, i32 1
store float* %647, float** %8
store float %645, float* %646
br label %648
648: ; preds = %644, %640
%649 = load i64, i64* %54
%650 = and i64 %649, 4096
%651 = icmp ne i64 %650, 0
br i1 %651, label %652, label %656
652: ; preds = %648
%653 = load float, float* %43
%654 = load float*, float** %8
%655 = getelementptr inbounds float, float* %654, i32 1
store float* %655, float** %8
store float %653, float* %654
br label %656
656: ; preds = %652, %648
%657 = load i64, i64* %54
%658 = and i64 %657, 8192
%659 = icmp ne i64 %658, 0
br i1 %659, label %660, label %664
660: ; preds = %656
%661 = load float, float* %44
%662 = load float*, float** %8
%663 = getelementptr inbounds float, float* %662, i32 1
store float* %663, float** %8
store float %661, float* %662
br label %664
664: ; preds = %660, %656
%665 = load i64, i64* %54
%666 = and i64 %665, 16384
%667 = icmp ne i64 %666, 0
br i1 %667, label %668, label %672
668: ; preds = %664
%669 = load float, float* %45
%670 = load float*, float** %8
%671 = getelementptr inbounds float, float* %670, i32 1
store float* %671, float** %8
store float %669, float* %670
br label %672
672: ; preds = %668, %664
%673 = load i64, i64* %54
%674 = and i64 %673, 32768
%675 = icmp ne i64 %674, 0
br i1 %675, label %676, label %680
676: ; preds = %672
%677 = load float, float* %46
%678 = load float*, float** %8
%679 = getelementptr inbounds float, float* %678, i32 1
store float* %679, float** %8
store float %677, float* %678
br label %680
680: ; preds = %676, %672
%681 = load i64, i64* %54
%682 = and i64 %681, 65536
%683 = icmp ne i64 %682, 0
br i1 %683, label %684, label %688
684: ; preds = %680
%685 = load float, float* %47
%686 = load float*, float** %8
%687 = getelementptr inbounds float, float* %686, i32 1
store float* %687, float** %8
store float %685, float* %686
br label %688
688: ; preds = %684, %680
%689 = load i64, i64* %54
%690 = and i64 %689, 131072
%691 = icmp ne i64 %690, 0
br i1 %691, label %692, label %696
692: ; preds = %688
%693 = load float, float* %48
%694 = load float*, float** %8
%695 = getelementptr inbounds float, float* %694, i32 1
store float* %695, float** %8
store float %693, float* %694
br label %696
696: ; preds = %692, %688
%697 = load i64, i64* %54
%698 = and i64 %697, 262144
%699 = icmp ne i64 %698, 0
br i1 %699, label %700, label %704
700: ; preds = %696
%701 = load float, float* %49
%702 = load float*, float** %8
%703 = getelementptr inbounds float, float* %702, i32 1
store float* %703, float** %8
store float %701, float* %702
br label %704
704: ; preds = %700, %696
%705 = load i64, i64* %54
%706 = and i64 %705, 524288
%707 = icmp ne i64 %706, 0
br i1 %707, label %708, label %712
708: ; preds = %704
%709 = load float, float* %50
%710 = load float*, float** %8
%711 = getelementptr inbounds float, float* %710, i32 1
store float* %711, float** %8
store float %709, float* %710
br label %712
712: ; preds = %708, %704
br label %713
713: ; preds = %712
%714 = load i64, i64* %55
%715 = add i64 %714, 1
store i64 %715, i64* %55
br label %56
716: ; preds = %56
%717 = load float, float* %11
%718 = load float, float* %12
%719 = fadd float %717, %718
%720 = load float, float* %13
%721 = fadd float %719, %720
%722 = load float, float* %14
%723 = fadd float %721, %722
%724 = load float, float* %15
%725 = fadd float %723, %724
%726 = load float, float* %16
%727 = fadd float %725, %726
%728 = load float, float* %17
%729 = fadd float %727, %728
%730 = load float, float* %18
%731 = fadd float %729, %730
%732 = load float, float* %19
%733 = fadd float %731, %732
%734 = load float, float* %20
%735 = fadd float %733, %734
%736 = load float, float* %21
%737 = fadd float %735, %736
%738 = load float, float* %22
%739 = fadd float %737, %738
%740 = load float, float* %23
%741 = fadd float %739, %740
%742 = load float, float* %24
%743 = fadd float %741, %742
%744 = load float, float* %25
%745 = fadd float %743, %744
%746 = load float, float* %26
%747 = fadd float %745, %746
%748 = load float, float* %27
%749 = fadd float %747, %748
%750 = load float, float* %28
%751 = fadd float %749, %750
%752 = load float, float* %29
%753 = fadd float %751, %752
%754 = load float, float* %30
%755 = fadd float %753, %754
%756 = load float, float* %31
%757 = fadd float %755, %756
%758 = load float, float* %32
%759 = fadd float %757, %758
%760 = load float, float* %33
%761 = fadd float %759, %760
%762 = load float, float* %34
%763 = fadd float %761, %762
%764 = load float, float* %35
%765 = fadd float %763, %764
%766 = load float, float* %36
%767 = fadd float %765, %766
%768 = load float, float* %37
%769 = fadd float %767, %768
%770 = load float, float* %38
%771 = fadd float %769, %770
%772 = load float, float* %39
%773 = fadd float %771, %772
%774 = load float, float* %40
%775 = fadd float %773, %774
%776 = load float, float* %41
%777 = fadd float %775, %776
%778 = load float, float* %42
%779 = fadd float %777, %778
%780 = load float, float* %43
%781 = fadd float %779, %780
%782 = load float, float* %44
%783 = fadd float %781, %782
%784 = load float, float* %45
%785 = fadd float %783, %784
%786 = load float, float* %46
%787 = fadd float %785, %786
%788 = load float, float* %47
%789 = fadd float %787, %788
%790 = load float, float* %48
%791 = fadd float %789, %790
%792 = load float, float* %49
%793 = fadd float %791, %792
%794 = load float, float* %50
%795 = fadd float %793, %794
ret float %795
}

LLVM IR (-O2):
define float @load_store_sf(i64 %0, float* nocapture %1, float* nocapture writeonly %2, i64* nocapture %3, i64* nocapture %4) {
%6 = icmp eq i64 %0, 0
br i1 %6, label %663, label %7
7: ; preds = %5, %619
%8 = phi i64 [ %621, %619 ], [ 0, %5 ]
%9 = phi float* [ %376, %619 ], [ %1, %5 ]
%10 = phi float* [ %620, %619 ], [ %2, %5 ]
%11 = phi i64* [ %55, %619 ], [ %3, %5 ]
%12 = phi i64* [ %379, %619 ], [ %4, %5 ]
%13 = phi float [ %375, %619 ], [ 0.000000e+00, %5 ]
%14 = phi float [ %367, %619 ], [ 0.000000e+00, %5 ]
%15 = phi float [ %359, %619 ], [ 0.000000e+00, %5 ]
%16 = phi float [ %351, %619 ], [ 0.000000e+00, %5 ]
%17 = phi float [ %343, %619 ], [ 0.000000e+00, %5 ]
%18 = phi float [ %335, %619 ], [ 0.000000e+00, %5 ]
%19 = phi float [ %327, %619 ], [ 0.000000e+00, %5 ]
%20 = phi float [ %319, %619 ], [ 0.000000e+00, %5 ]
%21 = phi float [ %311, %619 ], [ 0.000000e+00, %5 ]
%22 = phi float [ %303, %619 ], [ 0.000000e+00, %5 ]
%23 = phi float [ %295, %619 ], [ 0.000000e+00, %5 ]
%24 = phi float [ %287, %619 ], [ 0.000000e+00, %5 ]
%25 = phi float [ %279, %619 ], [ 0.000000e+00, %5 ]
%26 = phi float [ %271, %619 ], [ 0.000000e+00, %5 ]
%27 = phi float [ %263, %619 ], [ 0.000000e+00, %5 ]
%28 = phi float [ %255, %619 ], [ 0.000000e+00, %5 ]
%29 = phi float [ %247, %619 ], [ 0.000000e+00, %5 ]
%30 = phi float [ %239, %619 ], [ 0.000000e+00, %5 ]
%31 = phi float [ %231, %619 ], [ 0.000000e+00, %5 ]
%32 = phi float [ %223, %619 ], [ 0.000000e+00, %5 ]
%33 = phi float [ %215, %619 ], [ 0.000000e+00, %5 ]
%34 = phi float [ %207, %619 ], [ 0.000000e+00, %5 ]
%35 = phi float [ %199, %619 ], [ 0.000000e+00, %5 ]
%36 = phi float [ %191, %619 ], [ 0.000000e+00, %5 ]
%37 = phi float [ %183, %619 ], [ 0.000000e+00, %5 ]
%38 = phi float [ %175, %619 ], [ 0.000000e+00, %5 ]
%39 = phi float [ %167, %619 ], [ 0.000000e+00, %5 ]
%40 = phi float [ %159, %619 ], [ 0.000000e+00, %5 ]
%41 = phi float [ %151, %619 ], [ 0.000000e+00, %5 ]
%42 = phi float [ %143, %619 ], [ 0.000000e+00, %5 ]
%43 = phi float [ %135, %619 ], [ 0.000000e+00, %5 ]
%44 = phi float [ %127, %619 ], [ 0.000000e+00, %5 ]
%45 = phi float [ %119, %619 ], [ 0.000000e+00, %5 ]
%46 = phi float [ %111, %619 ], [ 0.000000e+00, %5 ]
%47 = phi float [ %103, %619 ], [ 0.000000e+00, %5 ]
%48 = phi float [ %95, %619 ], [ 0.000000e+00, %5 ]
%49 = phi float [ %87, %619 ], [ 0.000000e+00, %5 ]
%50 = phi float [ %79, %619 ], [ 0.000000e+00, %5 ]
%51 = phi float [ %71, %619 ], [ 0.000000e+00, %5 ]
%52 = phi float [ %63, %619 ], [ 0.000000e+00, %5 ]
%53 = getelementptr inbounds i64, i64* %11, i64 1
%54 = load i64, i64* %11
%55 = getelementptr inbounds i64, i64* %11, i64 2
%56 = load i64, i64* %53
%57 = and i64 %54, 1
%58 = icmp eq i64 %57, 0
br i1 %58, label %62, label %59
59: ; preds = %7
%60 = getelementptr inbounds float, float* %9, i64 1
%61 = load float, float* %9
br label %62
62: ; preds = %59, %7
%63 = phi float [ %61, %59 ], [ %52, %7 ]
%64 = phi float* [ %60, %59 ], [ %9, %7 ]
%65 = and i64 %54, 2
%66 = icmp eq i64 %65, 0
br i1 %66, label %70, label %67
67: ; preds = %62
%68 = getelementptr inbounds float, float* %64, i64 1
%69 = load float, float* %64
br label %70
70: ; preds = %67, %62
%71 = phi float [ %69, %67 ], [ %51, %62 ]
%72 = phi float* [ %68, %67 ], [ %64, %62 ]
%73 = and i64 %54, 4
%74 = icmp eq i64 %73, 0
br i1 %74, label %78, label %75
75: ; preds = %70
%76 = getelementptr inbounds float, float* %72, i64 1
%77 = load float, float* %72
br label %78
78: ; preds = %75, %70
%79 = phi float [ %77, %75 ], [ %50, %70 ]
%80 = phi float* [ %76, %75 ], [ %72, %70 ]
%81 = and i64 %54, 8
%82 = icmp eq i64 %81, 0
br i1 %82, label %86, label %83
83: ; preds = %78
%84 = getelementptr inbounds float, float* %80, i64 1
%85 = load float, float* %80
br label %86
86: ; preds = %83, %78
%87 = phi float [ %85, %83 ], [ %49, %78 ]
%88 = phi float* [ %84, %83 ], [ %80, %78 ]
%89 = and i64 %54, 16
%90 = icmp eq i64 %89, 0
br i1 %90, label %94, label %91
91: ; preds = %86
%92 = getelementptr inbounds float, float* %88, i64 1
%93 = load float, float* %88
br label %94
94: ; preds = %91, %86
%95 = phi float [ %93, %91 ], [ %48, %86 ]
%96 = phi float* [ %92, %91 ], [ %88, %86 ]
%97 = and i64 %54, 32
%98 = icmp eq i64 %97, 0
br i1 %98, label %102, label %99
99: ; preds = %94
%100 = getelementptr inbounds float, float* %96, i64 1
%101 = load float, float* %96
br label %102
102: ; preds = %99, %94
%103 = phi float [ %101, %99 ], [ %47, %94 ]
%104 = phi float* [ %100, %99 ], [ %96, %94 ]
%105 = and i64 %54, 64
%106 = icmp eq i64 %105, 0
br i1 %106, label %110, label %107
107: ; preds = %102
%108 = getelementptr inbounds float, float* %104, i64 1
%109 = load float, float* %104
br label %110
110: ; preds = %107, %102
%111 = phi float [ %109, %107 ], [ %46, %102 ]
%112 = phi float* [ %108, %107 ], [ %104, %102 ]
%113 = and i64 %54, 128
%114 = icmp eq i64 %113, 0
br i1 %114, label %118, label %115
115: ; preds = %110
%116 = getelementptr inbounds float, float* %112, i64 1
%117 = load float, float* %112
br label %118
118: ; preds = %115, %110
%119 = phi float [ %117, %115 ], [ %45, %110 ]
%120 = phi float* [ %116, %115 ], [ %112, %110 ]
%121 = and i64 %54, 256
%122 = icmp eq i64 %121, 0
br i1 %122, label %126, label %123
123: ; preds = %118
%124 = getelementptr inbounds float, float* %120, i64 1
%125 = load float, float* %120
br label %126
126: ; preds = %123, %118
%127 = phi float [ %125, %123 ], [ %44, %118 ]
%128 = phi float* [ %124, %123 ], [ %120, %118 ]
%129 = and i64 %54, 512
%130 = icmp eq i64 %129, 0
br i1 %130, label %134, label %131
131: ; preds = %126
%132 = getelementptr inbounds float, float* %128, i64 1
%133 = load float, float* %128
br label %134
134: ; preds = %131, %126
%135 = phi float [ %133, %131 ], [ %43, %126 ]
%136 = phi float* [ %132, %131 ], [ %128, %126 ]
%137 = and i64 %54, 1024
%138 = icmp eq i64 %137, 0
br i1 %138, label %142, label %139
139: ; preds = %134
%140 = getelementptr inbounds float, float* %136, i64 1
%141 = load float, float* %136
br label %142
142: ; preds = %139, %134
%143 = phi float [ %141, %139 ], [ %42, %134 ]
%144 = phi float* [ %140, %139 ], [ %136, %134 ]
%145 = and i64 %54, 2048
%146 = icmp eq i64 %145, 0
br i1 %146, label %150, label %147
147: ; preds = %142
%148 = getelementptr inbounds float, float* %144, i64 1
%149 = load float, float* %144
br label %150
150: ; preds = %147, %142
%151 = phi float [ %149, %147 ], [ %41, %142 ]
%152 = phi float* [ %148, %147 ], [ %144, %142 ]
%153 = and i64 %54, 4096
%154 = icmp eq i64 %153, 0
br i1 %154, label %158, label %155
155: ; preds = %150
%156 = getelementptr inbounds float, float* %152, i64 1
%157 = load float, float* %152
br label %158
158: ; preds = %155, %150
%159 = phi float [ %157, %155 ], [ %40, %150 ]
%160 = phi float* [ %156, %155 ], [ %152, %150 ]
%161 = and i64 %54, 8192
%162 = icmp eq i64 %161, 0
br i1 %162, label %166, label %163
163: ; preds = %158
%164 = getelementptr inbounds float, float* %160, i64 1
%165 = load float, float* %160
br label %166
166: ; preds = %163, %158
%167 = phi float [ %165, %163 ], [ %39, %158 ]
%168 = phi float* [ %164, %163 ], [ %160, %158 ]
%169 = and i64 %54, 16384
%170 = icmp eq i64 %169, 0
br i1 %170, label %174, label %171
171: ; preds = %166
%172 = getelementptr inbounds float, float* %168, i64 1
%173 = load float, float* %168
br label %174
174: ; preds = %171, %166
%175 = phi float [ %173, %171 ], [ %38, %166 ]
%176 = phi float* [ %172, %171 ], [ %168, %166 ]
%177 = and i64 %54, 32768
%178 = icmp eq i64 %177, 0
br i1 %178, label %182, label %179
179: ; preds = %174
%180 = getelementptr inbounds float, float* %176, i64 1
%181 = load float, float* %176
br label %182
182: ; preds = %179, %174
%183 = phi float [ %181, %179 ], [ %37, %174 ]
%184 = phi float* [ %180, %179 ], [ %176, %174 ]
%185 = and i64 %54, 65536
%186 = icmp eq i64 %185, 0
br i1 %186, label %190, label %187
187: ; preds = %182
%188 = getelementptr inbounds float, float* %184, i64 1
%189 = load float, float* %184
br label %190
190: ; preds = %187, %182
%191 = phi float [ %189, %187 ], [ %36, %182 ]
%192 = phi float* [ %188, %187 ], [ %184, %182 ]
%193 = and i64 %54, 131072
%194 = icmp eq i64 %193, 0
br i1 %194, label %198, label %195
195: ; preds = %190
%196 = getelementptr inbounds float, float* %192, i64 1
%197 = load float, float* %192
br label %198
198: ; preds = %195, %190
%199 = phi float [ %197, %195 ], [ %35, %190 ]
%200 = phi float* [ %196, %195 ], [ %192, %190 ]
%201 = and i64 %54, 262144
%202 = icmp eq i64 %201, 0
br i1 %202, label %206, label %203
203: ; preds = %198
%204 = getelementptr inbounds float, float* %200, i64 1
%205 = load float, float* %200
br label %206
206: ; preds = %203, %198
%207 = phi float [ %205, %203 ], [ %34, %198 ]
%208 = phi float* [ %204, %203 ], [ %200, %198 ]
%209 = and i64 %54, 524288
%210 = icmp eq i64 %209, 0
br i1 %210, label %214, label %211
211: ; preds = %206
%212 = getelementptr inbounds float, float* %208, i64 1
%213 = load float, float* %208
br label %214
214: ; preds = %211, %206
%215 = phi float [ %213, %211 ], [ %33, %206 ]
%216 = phi float* [ %212, %211 ], [ %208, %206 ]
%217 = and i64 %56, 1
%218 = icmp eq i64 %217, 0
br i1 %218, label %222, label %219
219: ; preds = %214
%220 = getelementptr inbounds float, float* %216, i64 1
%221 = load float, float* %216
br label %222
222: ; preds = %219, %214
%223 = phi float [ %221, %219 ], [ %32, %214 ]
%224 = phi float* [ %220, %219 ], [ %216, %214 ]
%225 = and i64 %56, 2
%226 = icmp eq i64 %225, 0
br i1 %226, label %230, label %227
227: ; preds = %222
%228 = getelementptr inbounds float, float* %224, i64 1
%229 = load float, float* %224
br label %230
230: ; preds = %227, %222
%231 = phi float [ %229, %227 ], [ %31, %222 ]
%232 = phi float* [ %228, %227 ], [ %224, %222 ]
%233 = and i64 %56, 4
%234 = icmp eq i64 %233, 0
br i1 %234, label %238, label %235
235: ; preds = %230
%236 = getelementptr inbounds float, float* %232, i64 1
%237 = load float, float* %232
br label %238
238: ; preds = %235, %230
%239 = phi float [ %237, %235 ], [ %30, %230 ]
%240 = phi float* [ %236, %235 ], [ %232, %230 ]
%241 = and i64 %56, 8
%242 = icmp eq i64 %241, 0
br i1 %242, label %246, label %243
243: ; preds = %238
%244 = getelementptr inbounds float, float* %240, i64 1
%245 = load float, float* %240
br label %246
246: ; preds = %243, %238
%247 = phi float [ %245, %243 ], [ %29, %238 ]
%248 = phi float* [ %244, %243 ], [ %240, %238 ]
%249 = and i64 %56, 16
%250 = icmp eq i64 %249, 0
br i1 %250, label %254, label %251
251: ; preds = %246
%252 = getelementptr inbounds float, float* %248, i64 1
%253 = load float, float* %248
br label %254
254: ; preds = %251, %246
%255 = phi float [ %253, %251 ], [ %28, %246 ]
%256 = phi float* [ %252, %251 ], [ %248, %246 ]
%257 = and i64 %56, 32
%258 = icmp eq i64 %257, 0
br i1 %258, label %262, label %259
259: ; preds = %254
%260 = getelementptr inbounds float, float* %256, i64 1
%261 = load float, float* %256
br label %262
262: ; preds = %259, %254
%263 = phi float [ %261, %259 ], [ %27, %254 ]
%264 = phi float* [ %260, %259 ], [ %256, %254 ]
%265 = and i64 %56, 64
%266 = icmp eq i64 %265, 0
br i1 %266, label %270, label %267
267: ; preds = %262
%268 = getelementptr inbounds float, float* %264, i64 1
%269 = load float, float* %264
br label %270
270: ; preds = %267, %262
%271 = phi float [ %269, %267 ], [ %26, %262 ]
%272 = phi float* [ %268, %267 ], [ %264, %262 ]
%273 = and i64 %56, 128
%274 = icmp eq i64 %273, 0
br i1 %274, label %278, label %275
275: ; preds = %270
%276 = getelementptr inbounds float, float* %272, i64 1
%277 = load float, float* %272
br label %278
278: ; preds = %275, %270
%279 = phi float [ %277, %275 ], [ %25, %270 ]
%280 = phi float* [ %276, %275 ], [ %272, %270 ]
%281 = and i64 %56, 256
%282 = icmp eq i64 %281, 0
br i1 %282, label %286, label %283
283: ; preds = %278
%284 = getelementptr inbounds float, float* %280, i64 1
%285 = load float, float* %280
br label %286
286: ; preds = %283, %278
%287 = phi float [ %285, %283 ], [ %24, %278 ]
%288 = phi float* [ %284, %283 ], [ %280, %278 ]
%289 = and i64 %56, 512
%290 = icmp eq i64 %289, 0
br i1 %290, label %294, label %291
291: ; preds = %286
%292 = getelementptr inbounds float, float* %288, i64 1
%293 = load float, float* %288
br label %294
294: ; preds = %291, %286
%295 = phi float [ %293, %291 ], [ %23, %286 ]
%296 = phi float* [ %292, %291 ], [ %288, %286 ]
%297 = and i64 %56, 1024
%298 = icmp eq i64 %297, 0
br i1 %298, label %302, label %299
299: ; preds = %294
%300 = getelementptr inbounds float, float* %296, i64 1
%301 = load float, float* %296
br label %302
302: ; preds = %299, %294
%303 = phi float [ %301, %299 ], [ %22, %294 ]
%304 = phi float* [ %300, %299 ], [ %296, %294 ]
%305 = and i64 %56, 2048
%306 = icmp eq i64 %305, 0
br i1 %306, label %310, label %307
307: ; preds = %302
%308 = getelementptr inbounds float, float* %304, i64 1
%309 = load float, float* %304
br label %310
310: ; preds = %307, %302
%311 = phi float [ %309, %307 ], [ %21, %302 ]
%312 = phi float* [ %308, %307 ], [ %304, %302 ]
%313 = and i64 %56, 4096
%314 = icmp eq i64 %313, 0
br i1 %314, label %318, label %315
315: ; preds = %310
%316 = getelementptr inbounds float, float* %312, i64 1
%317 = load float, float* %312
br label %318
318: ; preds = %315, %310
%319 = phi float [ %317, %315 ], [ %20, %310 ]
%320 = phi float* [ %316, %315 ], [ %312, %310 ]
%321 = and i64 %56, 8192
%322 = icmp eq i64 %321, 0
br i1 %322, label %326, label %323
323: ; preds = %318
%324 = getelementptr inbounds float, float* %320, i64 1
%325 = load float, float* %320
br label %326
326: ; preds = %323, %318
%327 = phi float [ %325, %323 ], [ %19, %318 ]
%328 = phi float* [ %324, %323 ], [ %320, %318 ]
%329 = and i64 %56, 16384
%330 = icmp eq i64 %329, 0
br i1 %330, label %334, label %331
331: ; preds = %326
%332 = getelementptr inbounds float, float* %328, i64 1
%333 = load float, float* %328
br label %334
334: ; preds = %331, %326
%335 = phi float [ %333, %331 ], [ %18, %326 ]
%336 = phi float* [ %332, %331 ], [ %328, %326 ]
%337 = and i64 %56, 32768
%338 = icmp eq i64 %337, 0
br i1 %338, label %342, label %339
339: ; preds = %334
%340 = getelementptr inbounds float, float* %336, i64 1
%341 = load float, float* %336
br label %342
342: ; preds = %339, %334
%343 = phi float [ %341, %339 ], [ %17, %334 ]
%344 = phi float* [ %340, %339 ], [ %336, %334 ]
%345 = and i64 %56, 65536
%346 = icmp eq i64 %345, 0
br i1 %346, label %350, label %347
347: ; preds = %342
%348 = getelementptr inbounds float, float* %344, i64 1
%349 = load float, float* %344
br label %350
350: ; preds = %347, %342
%351 = phi float [ %349, %347 ], [ %16, %342 ]
%352 = phi float* [ %348, %347 ], [ %344, %342 ]
%353 = and i64 %56, 131072
%354 = icmp eq i64 %353, 0
br i1 %354, label %358, label %355
355: ; preds = %350
%356 = getelementptr inbounds float, float* %352, i64 1
%357 = load float, float* %352
br label %358
358: ; preds = %355, %350
%359 = phi float [ %357, %355 ], [ %15, %350 ]
%360 = phi float* [ %356, %355 ], [ %352, %350 ]
%361 = and i64 %56, 262144
%362 = icmp eq i64 %361, 0
br i1 %362, label %366, label %363
363: ; preds = %358
%364 = getelementptr inbounds float, float* %360, i64 1
%365 = load float, float* %360
br label %366
366: ; preds = %363, %358
%367 = phi float [ %365, %363 ], [ %14, %358 ]
%368 = phi float* [ %364, %363 ], [ %360, %358 ]
%369 = and i64 %56, 524288
%370 = icmp eq i64 %369, 0
br i1 %370, label %374, label %371
371: ; preds = %366
%372 = getelementptr inbounds float, float* %368, i64 1
%373 = load float, float* %368
br label %374
374: ; preds = %371, %366
%375 = phi float [ %373, %371 ], [ %13, %366 ]
%376 = phi float* [ %372, %371 ], [ %368, %366 ]
%377 = getelementptr inbounds i64, i64* %12, i64 1
%378 = load i64, i64* %12
%379 = getelementptr inbounds i64, i64* %12, i64 2
%380 = load i64, i64* %377
%381 = and i64 %378, 1
%382 = icmp eq i64 %381, 0
br i1 %382, label %385, label %383
383: ; preds = %374
%384 = getelementptr inbounds float, float* %10, i64 1
store float %63, float* %10
br label %385
385: ; preds = %383, %374
%386 = phi float* [ %384, %383 ], [ %10, %374 ]
%387 = and i64 %378, 2
%388 = icmp eq i64 %387, 0
br i1 %388, label %391, label %389
389: ; preds = %385
%390 = getelementptr inbounds float, float* %386, i64 1
store float %71, float* %386
br label %391
391: ; preds = %389, %385
%392 = phi float* [ %390, %389 ], [ %386, %385 ]
%393 = and i64 %378, 4
%394 = icmp eq i64 %393, 0
br i1 %394, label %397, label %395
395: ; preds = %391
%396 = getelementptr inbounds float, float* %392, i64 1
store float %79, float* %392
br label %397
397: ; preds = %395, %391
%398 = phi float* [ %396, %395 ], [ %392, %391 ]
%399 = and i64 %378, 8
%400 = icmp eq i64 %399, 0
br i1 %400, label %403, label %401
401: ; preds = %397
%402 = getelementptr inbounds float, float* %398, i64 1
store float %87, float* %398
br label %403
403: ; preds = %401, %397
%404 = phi float* [ %402, %401 ], [ %398, %397 ]
%405 = and i64 %378, 16
%406 = icmp eq i64 %405, 0
br i1 %406, label %409, label %407
407: ; preds = %403
%408 = getelementptr inbounds float, float* %404, i64 1
store float %95, float* %404
br label %409
409: ; preds = %407, %403
%410 = phi float* [ %408, %407 ], [ %404, %403 ]
%411 = and i64 %378, 32
%412 = icmp eq i64 %411, 0
br i1 %412, label %415, label %413
413: ; preds = %409
%414 = getelementptr inbounds float, float* %410, i64 1
store float %103, float* %410
br label %415
415: ; preds = %413, %409
%416 = phi float* [ %414, %413 ], [ %410, %409 ]
%417 = and i64 %378, 64
%418 = icmp eq i64 %417, 0
br i1 %418, label %421, label %419
419: ; preds = %415
%420 = getelementptr inbounds float, float* %416, i64 1
store float %111, float* %416
br label %421
421: ; preds = %419, %415
%422 = phi float* [ %420, %419 ], [ %416, %415 ]
%423 = and i64 %378, 128
%424 = icmp eq i64 %423, 0
br i1 %424, label %427, label %425
425: ; preds = %421
%426 = getelementptr inbounds float, float* %422, i64 1
store float %119, float* %422
br label %427
427: ; preds = %425, %421
%428 = phi float* [ %426, %425 ], [ %422, %421 ]
%429 = and i64 %378, 256
%430 = icmp eq i64 %429, 0
br i1 %430, label %433, label %431
431: ; preds = %427
%432 = getelementptr inbounds float, float* %428, i64 1
store float %127, float* %428
br label %433
433: ; preds = %431, %427
%434 = phi float* [ %432, %431 ], [ %428, %427 ]
%435 = and i64 %378, 512
%436 = icmp eq i64 %435, 0
br i1 %436, label %439, label %437
437: ; preds = %433
%438 = getelementptr inbounds float, float* %434, i64 1
store float %135, float* %434
br label %439
439: ; preds = %437, %433
%440 = phi float* [ %438, %437 ], [ %434, %433 ]
%441 = and i64 %378, 1024
%442 = icmp eq i64 %441, 0
br i1 %442, label %445, label %443
443: ; preds = %439
%444 = getelementptr inbounds float, float* %440, i64 1
store float %143, float* %440
br label %445
445: ; preds = %443, %439
%446 = phi float* [ %444, %443 ], [ %440, %439 ]
%447 = and i64 %378, 2048
%448 = icmp eq i64 %447, 0
br i1 %448, label %451, label %449
449: ; preds = %445
%450 = getelementptr inbounds float, float* %446, i64 1
store float %151, float* %446
br label %451
451: ; preds = %449, %445
%452 = phi float* [ %450, %449 ], [ %446, %445 ]
%453 = and i64 %378, 4096
%454 = icmp eq i64 %453, 0
br i1 %454, label %457, label %455
455: ; preds = %451
%456 = getelementptr inbounds float, float* %452, i64 1
store float %159, float* %452
br label %457
457: ; preds = %455, %451
%458 = phi float* [ %456, %455 ], [ %452, %451 ]
%459 = and i64 %378, 8192
%460 = icmp eq i64 %459, 0
br i1 %460, label %463, label %461
461: ; preds = %457
%462 = getelementptr inbounds float, float* %458, i64 1
store float %167, float* %458
br label %463
463: ; preds = %461, %457
%464 = phi float* [ %462, %461 ], [ %458, %457 ]
%465 = and i64 %378, 16384
%466 = icmp eq i64 %465, 0
br i1 %466, label %469, label %467
467: ; preds = %463
%468 = getelementptr inbounds float, float* %464, i64 1
store float %175, float* %464
br label %469
469: ; preds = %467, %463
%470 = phi float* [ %468, %467 ], [ %464, %463 ]
%471 = and i64 %378, 32768
%472 = icmp eq i64 %471, 0
br i1 %472, label %475, label %473
473: ; preds = %469
%474 = getelementptr inbounds float, float* %470, i64 1
store float %183, float* %470
br label %475
475: ; preds = %473, %469
%476 = phi float* [ %474, %473 ], [ %470, %469 ]
%477 = and i64 %378, 65536
%478 = icmp eq i64 %477, 0
br i1 %478, label %481, label %479
479: ; preds = %475
%480 = getelementptr inbounds float, float* %476, i64 1
store float %191, float* %476
br label %481
481: ; preds = %479, %475
%482 = phi float* [ %480, %479 ], [ %476, %475 ]
%483 = and i64 %378, 131072
%484 = icmp eq i64 %483, 0
br i1 %484, label %487, label %485
485: ; preds = %481
%486 = getelementptr inbounds float, float* %482, i64 1
store float %199, float* %482
br label %487
487: ; preds = %485, %481
%488 = phi float* [ %486, %485 ], [ %482, %481 ]
%489 = and i64 %378, 262144
%490 = icmp eq i64 %489, 0
br i1 %490, label %493, label %491
491: ; preds = %487
%492 = getelementptr inbounds float, float* %488, i64 1
store float %207, float* %488
br label %493
493: ; preds = %491, %487
%494 = phi float* [ %492, %491 ], [ %488, %487 ]
%495 = and i64 %378, 524288
%496 = icmp eq i64 %495, 0
br i1 %496, label %499, label %497
497: ; preds = %493
%498 = getelementptr inbounds float, float* %494, i64 1
store float %215, float* %494
br label %499
499: ; preds = %497, %493
%500 = phi float* [ %498, %497 ], [ %494, %493 ]
%501 = and i64 %380, 1
%502 = icmp eq i64 %501, 0
br i1 %502, label %505, label %503
503: ; preds = %499
%504 = getelementptr inbounds float, float* %500, i64 1
store float %223, float* %500
br label %505
505: ; preds = %503, %499
%506 = phi float* [ %504, %503 ], [ %500, %499 ]
%507 = and i64 %380, 2
%508 = icmp eq i64 %507, 0
br i1 %508, label %511, label %509
509: ; preds = %505
%510 = getelementptr inbounds float, float* %506, i64 1
store float %231, float* %506
br label %511
511: ; preds = %509, %505
%512 = phi float* [ %510, %509 ], [ %506, %505 ]
%513 = and i64 %380, 4
%514 = icmp eq i64 %513, 0
br i1 %514, label %517, label %515
515: ; preds = %511
%516 = getelementptr inbounds float, float* %512, i64 1
store float %239, float* %512
br label %517
517: ; preds = %515, %511
%518 = phi float* [ %516, %515 ], [ %512, %511 ]
%519 = and i64 %380, 8
%520 = icmp eq i64 %519, 0
br i1 %520, label %523, label %521
521: ; preds = %517
%522 = getelementptr inbounds float, float* %518, i64 1
store float %247, float* %518
br label %523
523: ; preds = %521, %517
%524 = phi float* [ %522, %521 ], [ %518, %517 ]
%525 = and i64 %380, 16
%526 = icmp eq i64 %525, 0
br i1 %526, label %529, label %527
527: ; preds = %523
%528 = getelementptr inbounds float, float* %524, i64 1
store float %255, float* %524
br label %529
529: ; preds = %527, %523
%530 = phi float* [ %528, %527 ], [ %524, %523 ]
%531 = and i64 %380, 32
%532 = icmp eq i64 %531, 0
br i1 %532, label %535, label %533
533: ; preds = %529
%534 = getelementptr inbounds float, float* %530, i64 1
store float %263, float* %530
br label %535
535: ; preds = %533, %529
%536 = phi float* [ %534, %533 ], [ %530, %529 ]
%537 = and i64 %380, 64
%538 = icmp eq i64 %537, 0
br i1 %538, label %541, label %539
539: ; preds = %535
%540 = getelementptr inbounds float, float* %536, i64 1
store float %271, float* %536
br label %541
541: ; preds = %539, %535
%542 = phi float* [ %540, %539 ], [ %536, %535 ]
%543 = and i64 %380, 128
%544 = icmp eq i64 %543, 0
br i1 %544, label %547, label %545
545: ; preds = %541
%546 = getelementptr inbounds float, float* %542, i64 1
store float %279, float* %542
br label %547
547: ; preds = %545, %541
%548 = phi float* [ %546, %545 ], [ %542, %541 ]
%549 = and i64 %380, 256
%550 = icmp eq i64 %549, 0
br i1 %550, label %553, label %551
551: ; preds = %547
%552 = getelementptr inbounds float, float* %548, i64 1
store float %287, float* %548
br label %553
553: ; preds = %551, %547
%554 = phi float* [ %552, %551 ], [ %548, %547 ]
%555 = and i64 %380, 512
%556 = icmp eq i64 %555, 0
br i1 %556, label %559, label %557
557: ; preds = %553
%558 = getelementptr inbounds float, float* %554, i64 1
store float %295, float* %554
br label %559
559: ; preds = %557, %553
%560 = phi float* [ %558, %557 ], [ %554, %553 ]
%561 = and i64 %380, 1024
%562 = icmp eq i64 %561, 0
br i1 %562, label %565, label %563
563: ; preds = %559
%564 = getelementptr inbounds float, float* %560, i64 1
store float %303, float* %560
br label %565
565: ; preds = %563, %559
%566 = phi float* [ %564, %563 ], [ %560, %559 ]
%567 = and i64 %380, 2048
%568 = icmp eq i64 %567, 0
br i1 %568, label %571, label %569
569: ; preds = %565
%570 = getelementptr inbounds float, float* %566, i64 1
store float %311, float* %566
br label %571
571: ; preds = %569, %565
%572 = phi float* [ %570, %569 ], [ %566, %565 ]
%573 = and i64 %380, 4096
%574 = icmp eq i64 %573, 0
br i1 %574, label %577, label %575
575: ; preds = %571
%576 = getelementptr inbounds float, float* %572, i64 1
store float %319, float* %572
br label %577
577: ; preds = %575, %571
%578 = phi float* [ %576, %575 ], [ %572, %571 ]
%579 = and i64 %380, 8192
%580 = icmp eq i64 %579, 0
br i1 %580, label %583, label %581
581: ; preds = %577
%582 = getelementptr inbounds float, float* %578, i64 1
store float %327, float* %578
br label %583
583: ; preds = %581, %577
%584 = phi float* [ %582, %581 ], [ %578, %577 ]
%585 = and i64 %380, 16384
%586 = icmp eq i64 %585, 0
br i1 %586, label %589, label %587
587: ; preds = %583
%588 = getelementptr inbounds float, float* %584, i64 1
store float %335, float* %584
br label %589
589: ; preds = %587, %583
%590 = phi float* [ %588, %587 ], [ %584, %583 ]
%591 = and i64 %380, 32768
%592 = icmp eq i64 %591, 0
br i1 %592, label %595, label %593
593: ; preds = %589
%594 = getelementptr inbounds float, float* %590, i64 1
store float %343, float* %590
br label %595
595: ; preds = %593, %589
%596 = phi float* [ %594, %593 ], [ %590, %589 ]
%597 = and i64 %380, 65536
%598 = icmp eq i64 %597, 0
br i1 %598, label %601, label %599
599: ; preds = %595
%600 = getelementptr inbounds float, float* %596, i64 1
store float %351, float* %596
br label %601
601: ; preds = %599, %595
%602 = phi float* [ %600, %599 ], [ %596, %595 ]
%603 = and i64 %380, 131072
%604 = icmp eq i64 %603, 0
br i1 %604, label %607, label %605
605: ; preds = %601
%606 = getelementptr inbounds float, float* %602, i64 1
store float %359, float* %602
br label %607
607: ; preds = %605, %601
%608 = phi float* [ %606, %605 ], [ %602, %601 ]
%609 = and i64 %380, 262144
%610 = icmp eq i64 %609, 0
br i1 %610, label %613, label %611
611: ; preds = %607
%612 = getelementptr inbounds float, float* %608, i64 1
store float %367, float* %608
br label %613
613: ; preds = %611, %607
%614 = phi float* [ %612, %611 ], [ %608, %607 ]
%615 = and i64 %380, 524288
%616 = icmp eq i64 %615, 0
br i1 %616, label %619, label %617
617: ; preds = %613
%618 = getelementptr inbounds float, float* %614, i64 1
store float %375, float* %614
br label %619
619: ; preds = %613, %617
%620 = phi float* [ %618, %617 ], [ %614, %613 ]
%621 = add nuw i64 %8, 1
%622 = icmp eq i64 %621, %0
br i1 %622, label %623, label %7
623: ; preds = %619
%624 = fadd float %63, %71
%625 = fadd float %624, %79
%626 = fadd float %625, %87
%627 = fadd float %626, %95
%628 = fadd float %627, %103
%629 = fadd float %628, %111
%630 = fadd float %629, %119
%631 = fadd float %630, %127
%632 = fadd float %631, %135
%633 = fadd float %632, %143
%634 = fadd float %633, %151
%635 = fadd float %634, %159
%636 = fadd float %635, %167
%637 = fadd float %636, %175
%638 = fadd float %637, %183
%639 = fadd float %638, %191
%640 = fadd float %639, %199
%641 = fadd float %640, %207
%642 = fadd float %641, %215
%643 = fadd float %642, %223
%644 = fadd float %643, %231
%645 = fadd float %644, %239
%646 = fadd float %645, %247
%647 = fadd float %646, %255
%648 = fadd float %647, %263
%649 = fadd float %648, %271
%650 = fadd float %649, %279
%651 = fadd float %650, %287
%652 = fadd float %651, %295
%653 = fadd float %652, %303
%654 = fadd float %653, %311
%655 = fadd float %654, %319
%656 = fadd float %655, %327
%657 = fadd float %656, %335
%658 = fadd float %657, %343
%659 = fadd float %658, %351
%660 = fadd float %659, %359
%661 = fadd float %660, %367
%662 = fadd float %661, %375
br label %663
663: ; preds = %623, %5
%664 = phi float [ %662, %623 ], [ 0.000000e+00, %5 ]
ret float %664
}