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;
  unsigned long out_mask;
  unsigned long i;
  for (i = 0; i < num; i++) {
    in_mask = *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_mask & (1L << 20)) != 0L)
      value20 = *from_ptr++;
    if ((in_mask & (1L << 21)) != 0L)
      value21 = *from_ptr++;
    if ((in_mask & (1L << 22)) != 0L)
      value22 = *from_ptr++;
    if ((in_mask & (1L << 23)) != 0L)
      value23 = *from_ptr++;
    if ((in_mask & (1L << 24)) != 0L)
      value24 = *from_ptr++;
    if ((in_mask & (1L << 25)) != 0L)
      value25 = *from_ptr++;
    if ((in_mask & (1L << 26)) != 0L)
      value26 = *from_ptr++;
    if ((in_mask & (1L << 27)) != 0L)
      value27 = *from_ptr++;
    if ((in_mask & (1L << 28)) != 0L)
      value28 = *from_ptr++;
    if ((in_mask & (1L << 29)) != 0L)
      value29 = *from_ptr++;
    if ((in_mask & (1L << 30)) != 0L)
      value30 = *from_ptr++;
    if ((in_mask & (1L << 31)) != 0L)
      value31 = *from_ptr++;
    if ((in_mask & (1L << 32)) != 0L)
      value32 = *from_ptr++;
    if ((in_mask & (1L << 33)) != 0L)
      value33 = *from_ptr++;
    if ((in_mask & (1L << 34)) != 0L)
      value34 = *from_ptr++;
    if ((in_mask & (1L << 35)) != 0L)
      value35 = *from_ptr++;
    if ((in_mask & (1L << 36)) != 0L)
      value36 = *from_ptr++;
    if ((in_mask & (1L << 37)) != 0L)
      value37 = *from_ptr++;
    if ((in_mask & (1L << 38)) != 0L)
      value38 = *from_ptr++;
    if ((in_mask & (1L << 39)) != 0L)
      value39 = *from_ptr++;
    out_mask = *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_mask & (1L << 20)) != 0L)
      *to_ptr++ = value20;
    if ((out_mask & (1L << 21)) != 0L)
      *to_ptr++ = value21;
    if ((out_mask & (1L << 22)) != 0L)
      *to_ptr++ = value22;
    if ((out_mask & (1L << 23)) != 0L)
      *to_ptr++ = value23;
    if ((out_mask & (1L << 24)) != 0L)
      *to_ptr++ = value24;
    if ((out_mask & (1L << 25)) != 0L)
      *to_ptr++ = value25;
    if ((out_mask & (1L << 26)) != 0L)
      *to_ptr++ = value26;
    if ((out_mask & (1L << 27)) != 0L)
      *to_ptr++ = value27;
    if ((out_mask & (1L << 28)) != 0L)
      *to_ptr++ = value28;
    if ((out_mask & (1L << 29)) != 0L)
      *to_ptr++ = value29;
    if ((out_mask & (1L << 30)) != 0L)
      *to_ptr++ = value30;
    if ((out_mask & (1L << 31)) != 0L)
      *to_ptr++ = value31;
    if ((out_mask & (1L << 32)) != 0L)
      *to_ptr++ = value32;
    if ((out_mask & (1L << 33)) != 0L)
      *to_ptr++ = value33;
    if ((out_mask & (1L << 34)) != 0L)
      *to_ptr++ = value34;
    if ((out_mask & (1L << 35)) != 0L)
      *to_ptr++ = value35;
    if ((out_mask & (1L << 36)) != 0L)
      *to_ptr++ = value36;
    if ((out_mask & (1L << 37)) != 0L)
      *to_ptr++ = value37;
    if ((out_mask & (1L << 38)) != 0L)
      *to_ptr++ = value38;
    if ((out_mask & (1L << 39)) != 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    $0x60,%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,-0xe0(%rbp)
mov    -0xe0(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    2244 <load_store_sf+0x1144>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%rax
mov    %rax,-0xd0(%rbp)
mov    -0xd0(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     12f4 <load_store_sf+0x1f4>
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     1321 <load_store_sf+0x221>
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     134e <load_store_sf+0x24e>
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     137b <load_store_sf+0x27b>
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     13a8 <load_store_sf+0x2a8>
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     13d5 <load_store_sf+0x2d5>
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     1402 <load_store_sf+0x302>
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     1431 <load_store_sf+0x331>
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     1460 <load_store_sf+0x360>
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     148f <load_store_sf+0x38f>
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     14be <load_store_sf+0x3be>
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     14ed <load_store_sf+0x3ed>
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     151c <load_store_sf+0x41c>
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     154b <load_store_sf+0x44b>
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     157a <load_store_sf+0x47a>
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     15a9 <load_store_sf+0x4a9>
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     15d8 <load_store_sf+0x4d8>
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     1607 <load_store_sf+0x507>
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     1636 <load_store_sf+0x536>
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     1665 <load_store_sf+0x565>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0xd0(%rbp),%rax
and    $0x100000,%rax
cmp    $0x0,%rax
je     1694 <load_store_sf+0x594>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0xd0(%rbp),%rax
and    $0x200000,%rax
cmp    $0x0,%rax
je     16c3 <load_store_sf+0x5c3>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0xd0(%rbp),%rax
and    $0x400000,%rax
cmp    $0x0,%rax
je     16f5 <load_store_sf+0x5f5>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    -0xd0(%rbp),%rax
and    $0x800000,%rax
cmp    $0x0,%rax
je     1727 <load_store_sf+0x627>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    -0xd0(%rbp),%rax
and    $0x1000000,%rax
cmp    $0x0,%rax
je     1759 <load_store_sf+0x659>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0xd0(%rbp),%rax
and    $0x2000000,%rax
cmp    $0x0,%rax
je     178b <load_store_sf+0x68b>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    -0xd0(%rbp),%rax
and    $0x4000000,%rax
cmp    $0x0,%rax
je     17bd <load_store_sf+0x6bd>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0xd0(%rbp),%rax
and    $0x8000000,%rax
cmp    $0x0,%rax
je     17ef <load_store_sf+0x6ef>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    -0xd0(%rbp),%rax
and    $0x10000000,%rax
cmp    $0x0,%rax
je     1821 <load_store_sf+0x721>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
mov    -0xd0(%rbp),%rax
and    $0x20000000,%rax
cmp    $0x0,%rax
je     1853 <load_store_sf+0x753>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
mov    -0xd0(%rbp),%rax
and    $0x40000000,%rax
cmp    $0x0,%rax
je     1885 <load_store_sf+0x785>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movabs $0x80000000,%rax
and    -0xd0(%rbp),%rax
cmp    $0x0,%rax
je     18bb <load_store_sf+0x7bb>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
movabs $0x100000000,%rax
and    -0xd0(%rbp),%rax
cmp    $0x0,%rax
je     18f1 <load_store_sf+0x7f1>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xac(%rbp)
ff
movabs $0x200000000,%rax
and    -0xd0(%rbp),%rax
cmp    $0x0,%rax
je     1927 <load_store_sf+0x827>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movabs $0x400000000,%rax
and    -0xd0(%rbp),%rax
cmp    $0x0,%rax
je     195d <load_store_sf+0x85d>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movabs $0x800000000,%rax
and    -0xd0(%rbp),%rax
cmp    $0x0,%rax
je     1993 <load_store_sf+0x893>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
movabs $0x1000000000,%rax
and    -0xd0(%rbp),%rax
cmp    $0x0,%rax
je     19c9 <load_store_sf+0x8c9>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movabs $0x2000000000,%rax
and    -0xd0(%rbp),%rax
cmp    $0x0,%rax
je     19ff <load_store_sf+0x8ff>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xc0(%rbp)
ff
movabs $0x4000000000,%rax
and    -0xd0(%rbp),%rax
cmp    $0x0,%rax
je     1a35 <load_store_sf+0x935>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
movabs $0x8000000000,%rax
and    -0xd0(%rbp),%rax
cmp    $0x0,%rax
je     1a6b <load_store_sf+0x96b>
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,-0xd8(%rbp)
mov    -0xd8(%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    -0xd8(%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    -0xd8(%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    -0xd8(%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    -0xd8(%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    -0xd8(%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    -0xd8(%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    -0xd8(%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    -0xd8(%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    -0xd8(%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    -0xd8(%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    -0xd8(%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    -0xd8(%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    -0xd8(%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    -0xd8(%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    -0xd8(%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    -0xd8(%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    -0xd8(%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    -0xd8(%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    -0xd8(%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    -0xd8(%rbp),%rax
and    $0x100000,%rax
cmp    $0x0,%rax
je     1e51 <load_store_sf+0xd51>
movss  -0x7c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xd8(%rbp),%rax
and    $0x200000,%rax
cmp    $0x0,%rax
je     1e80 <load_store_sf+0xd80>
movss  -0x80(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xd8(%rbp),%rax
and    $0x400000,%rax
cmp    $0x0,%rax
je     1eb2 <load_store_sf+0xdb2>
movss  -0x84(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xd8(%rbp),%rax
and    $0x800000,%rax
cmp    $0x0,%rax
je     1ee4 <load_store_sf+0xde4>
movss  -0x88(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xd8(%rbp),%rax
and    $0x1000000,%rax
cmp    $0x0,%rax
je     1f16 <load_store_sf+0xe16>
movss  -0x8c(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xd8(%rbp),%rax
and    $0x2000000,%rax
cmp    $0x0,%rax
je     1f48 <load_store_sf+0xe48>
movss  -0x90(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xd8(%rbp),%rax
and    $0x4000000,%rax
cmp    $0x0,%rax
je     1f7a <load_store_sf+0xe7a>
movss  -0x94(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xd8(%rbp),%rax
and    $0x8000000,%rax
cmp    $0x0,%rax
je     1fac <load_store_sf+0xeac>
movss  -0x98(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xd8(%rbp),%rax
and    $0x10000000,%rax
cmp    $0x0,%rax
je     1fde <load_store_sf+0xede>
movss  -0x9c(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xd8(%rbp),%rax
and    $0x20000000,%rax
cmp    $0x0,%rax
je     2010 <load_store_sf+0xf10>
movss  -0xa0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0xd8(%rbp),%rax
and    $0x40000000,%rax
cmp    $0x0,%rax
je     2042 <load_store_sf+0xf42>
movss  -0xa4(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
movabs $0x80000000,%rax
and    -0xd8(%rbp),%rax
cmp    $0x0,%rax
je     2078 <load_store_sf+0xf78>
movss  -0xa8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
movabs $0x100000000,%rax
and    -0xd8(%rbp),%rax
cmp    $0x0,%rax
je     20ae <load_store_sf+0xfae>
movss  -0xac(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
movabs $0x200000000,%rax
and    -0xd8(%rbp),%rax
cmp    $0x0,%rax
je     20e4 <load_store_sf+0xfe4>
movss  -0xb0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
movabs $0x400000000,%rax
and    -0xd8(%rbp),%rax
cmp    $0x0,%rax
je     211a <load_store_sf+0x101a>
movss  -0xb4(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
movabs $0x800000000,%rax
and    -0xd8(%rbp),%rax
cmp    $0x0,%rax
je     2150 <load_store_sf+0x1050>
movss  -0xb8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
movabs $0x1000000000,%rax
and    -0xd8(%rbp),%rax
cmp    $0x0,%rax
je     2186 <load_store_sf+0x1086>
movss  -0xbc(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
movabs $0x2000000000,%rax
and    -0xd8(%rbp),%rax
cmp    $0x0,%rax
je     21bc <load_store_sf+0x10bc>
movss  -0xc0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
movabs $0x4000000000,%rax
and    -0xd8(%rbp),%rax
cmp    $0x0,%rax
je     21f2 <load_store_sf+0x10f2>
movss  -0xc4(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
movabs $0x8000000000,%rax
and    -0xd8(%rbp),%rax
cmp    $0x0,%rax
je     2228 <load_store_sf+0x1128>
movss  -0xc8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
jmp    222d <load_store_sf+0x112d>
mov    -0xe0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xe0(%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    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<load_store_sf>:
test   %rdi,%rdi
je     1e22 <load_store_sf+0xd22>
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
movabs $0x8000000000,%r9
movabs $0x4000000000,%r10
movabs $0x2000000000,%r11
movabs $0x1000000000,%r14
movabs $0x800000000,%r15
movabs $0x400000000,%r12
movabs $0x200000000,%r13
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4(%rsp)
movabs $0x100000000,%rax
xor    %ebx,%ebx
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    128d <load_store_sf+0x18d>
nopl   (%rax)
add    $0x1,%rbx
cmp    %rbx,%rdi
je     1d41 <load_store_sf+0xc41>
mov    (%rcx,%rbx,8),%rbp
test   $0x1,%bpl
jne    1620 <load_store_sf+0x520>
test   $0x2,%bpl
jne    1632 <load_store_sf+0x532>
test   $0x4,%bpl
jne    1644 <load_store_sf+0x544>
test   $0x8,%bpl
jne    1657 <load_store_sf+0x557>
test   $0x10,%bpl
jne    166a <load_store_sf+0x56a>
test   $0x20,%bpl
jne    167d <load_store_sf+0x57d>
test   $0x40,%bpl
jne    1690 <load_store_sf+0x590>
test   $0x80,%bpl
jne    16a3 <load_store_sf+0x5a3>
test   $0x100,%ebp
jne    16b8 <load_store_sf+0x5b8>
test   $0x200,%ebp
jne    16cd <load_store_sf+0x5cd>
test   $0x400,%ebp
jne    16e2 <load_store_sf+0x5e2>
test   $0x800,%ebp
jne    16f6 <load_store_sf+0x5f6>
test   $0x1000,%ebp
jne    170a <load_store_sf+0x60a>
test   $0x2000,%ebp
jne    171e <load_store_sf+0x61e>
test   $0x4000,%ebp
jne    1732 <load_store_sf+0x632>
test   $0x8000,%ebp
jne    1746 <load_store_sf+0x646>
test   $0x10000,%ebp
jne    1760 <load_store_sf+0x660>
test   $0x20000,%ebp
jne    177a <load_store_sf+0x67a>
test   $0x40000,%ebp
jne    1794 <load_store_sf+0x694>
test   $0x80000,%ebp
jne    17ae <load_store_sf+0x6ae>
test   $0x100000,%ebp
jne    17c8 <load_store_sf+0x6c8>
test   $0x200000,%ebp
jne    17e2 <load_store_sf+0x6e2>
test   $0x400000,%ebp
jne    17fc <load_store_sf+0x6fc>
test   $0x800000,%ebp
jne    1816 <load_store_sf+0x716>
test   $0x1000000,%ebp
jne    1830 <load_store_sf+0x730>
test   $0x2000000,%ebp
jne    184a <load_store_sf+0x74a>
test   $0x4000000,%ebp
jne    1864 <load_store_sf+0x764>
test   $0x8000000,%ebp
jne    187e <load_store_sf+0x77e>
test   $0x10000000,%ebp
jne    1898 <load_store_sf+0x798>
test   $0x20000000,%ebp
jne    18b2 <load_store_sf+0x7b2>
test   $0x40000000,%ebp
jne    18cc <load_store_sf+0x7cc>
test   $0x80000000,%ebp
jne    18e6 <load_store_sf+0x7e6>
test   %rax,%rbp
jne    18fd <load_store_sf+0x7fd>
test   %r13,%rbp
jne    1914 <load_store_sf+0x814>
test   %r12,%rbp
jne    192b <load_store_sf+0x82b>
test   %r15,%rbp
jne    1942 <load_store_sf+0x842>
test   %r14,%rbp
jne    1959 <load_store_sf+0x859>
test   %r11,%rbp
jne    1970 <load_store_sf+0x870>
test   %r10,%rbp
jne    1987 <load_store_sf+0x887>
test   %r9,%rbp
je     1453 <load_store_sf+0x353>
movss  (%rsi),%xmm3
movss  %xmm3,-0x4(%rsp)
add    $0x4,%rsi
mov    (%r8,%rbx,8),%rbp
test   $0x1,%bpl
jne    19b0 <load_store_sf+0x8b0>
test   $0x2,%bpl
jne    19c2 <load_store_sf+0x8c2>
test   $0x4,%bpl
jne    19d4 <load_store_sf+0x8d4>
test   $0x8,%bpl
jne    19e7 <load_store_sf+0x8e7>
test   $0x10,%bpl
jne    19fa <load_store_sf+0x8fa>
test   $0x20,%bpl
jne    1a0d <load_store_sf+0x90d>
test   $0x40,%bpl
jne    1a20 <load_store_sf+0x920>
test   $0x80,%bpl
jne    1a33 <load_store_sf+0x933>
test   $0x100,%ebp
jne    1a48 <load_store_sf+0x948>
test   $0x200,%ebp
jne    1a5d <load_store_sf+0x95d>
test   $0x400,%ebp
jne    1a72 <load_store_sf+0x972>
test   $0x800,%ebp
jne    1a86 <load_store_sf+0x986>
test   $0x1000,%ebp
jne    1a9a <load_store_sf+0x99a>
test   $0x2000,%ebp
jne    1aae <load_store_sf+0x9ae>
test   $0x4000,%ebp
jne    1ac2 <load_store_sf+0x9c2>
test   $0x8000,%ebp
jne    1ad6 <load_store_sf+0x9d6>
test   $0x10000,%ebp
jne    1af0 <load_store_sf+0x9f0>
test   $0x20000,%ebp
jne    1b0a <load_store_sf+0xa0a>
test   $0x40000,%ebp
jne    1b24 <load_store_sf+0xa24>
test   $0x80000,%ebp
jne    1b3e <load_store_sf+0xa3e>
test   $0x100000,%ebp
jne    1b58 <load_store_sf+0xa58>
test   $0x200000,%ebp
jne    1b72 <load_store_sf+0xa72>
test   $0x400000,%ebp
jne    1b8c <load_store_sf+0xa8c>
test   $0x800000,%ebp
jne    1ba6 <load_store_sf+0xaa6>
test   $0x1000000,%ebp
jne    1bc0 <load_store_sf+0xac0>
test   $0x2000000,%ebp
jne    1bda <load_store_sf+0xada>
test   $0x4000000,%ebp
jne    1bf4 <load_store_sf+0xaf4>
test   $0x8000000,%ebp
jne    1c0e <load_store_sf+0xb0e>
test   $0x10000000,%ebp
jne    1c28 <load_store_sf+0xb28>
test   $0x20000000,%ebp
jne    1c42 <load_store_sf+0xb42>
test   $0x40000000,%ebp
jne    1c5c <load_store_sf+0xb5c>
test   $0x80000000,%ebp
jne    1c76 <load_store_sf+0xb76>
test   %rax,%rbp
jne    1c8d <load_store_sf+0xb8d>
test   %r13,%rbp
jne    1ca4 <load_store_sf+0xba4>
test   %r12,%rbp
jne    1cbb <load_store_sf+0xbbb>
test   %r15,%rbp
jne    1cd2 <load_store_sf+0xbd2>
test   %r14,%rbp
jne    1ce9 <load_store_sf+0xbe9>
test   %r11,%rbp
jne    1d00 <load_store_sf+0xc00>
test   %r10,%rbp
jne    1d17 <load_store_sf+0xc17>
test   %r9,%rbp
je     1280 <load_store_sf+0x180>
jmp    1d2e <load_store_sf+0xc2e>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rsi),%xmm0
add    $0x4,%rsi
test   $0x2,%bpl
je     12a5 <load_store_sf+0x1a5>
movss  (%rsi),%xmm2
add    $0x4,%rsi
test   $0x4,%bpl
je     12af <load_store_sf+0x1af>
movss  (%rsi),%xmm15
add    $0x4,%rsi
test   $0x8,%bpl
je     12b9 <load_store_sf+0x1b9>
movss  (%rsi),%xmm14
add    $0x4,%rsi
test   $0x10,%bpl
je     12c3 <load_store_sf+0x1c3>
movss  (%rsi),%xmm13
add    $0x4,%rsi
test   $0x20,%bpl
je     12cd <load_store_sf+0x1cd>
movss  (%rsi),%xmm12
add    $0x4,%rsi
test   $0x40,%bpl
je     12d7 <load_store_sf+0x1d7>
movss  (%rsi),%xmm11
add    $0x4,%rsi
test   $0x80,%bpl
je     12e1 <load_store_sf+0x1e1>
movss  (%rsi),%xmm10
add    $0x4,%rsi
test   $0x100,%ebp
je     12ed <load_store_sf+0x1ed>
movss  (%rsi),%xmm9
add    $0x4,%rsi
test   $0x200,%ebp
je     12f9 <load_store_sf+0x1f9>
movss  (%rsi),%xmm8
add    $0x4,%rsi
test   $0x400,%ebp
je     1305 <load_store_sf+0x205>
movss  (%rsi),%xmm1
add    $0x4,%rsi
test   $0x800,%ebp
je     1311 <load_store_sf+0x211>
movss  (%rsi),%xmm7
add    $0x4,%rsi
test   $0x1000,%ebp
je     131d <load_store_sf+0x21d>
movss  (%rsi),%xmm6
add    $0x4,%rsi
test   $0x2000,%ebp
je     1329 <load_store_sf+0x229>
movss  (%rsi),%xmm5
add    $0x4,%rsi
test   $0x4000,%ebp
je     1335 <load_store_sf+0x235>
movss  (%rsi),%xmm4
add    $0x4,%rsi
test   $0x8000,%ebp
je     1341 <load_store_sf+0x241>
movss  (%rsi),%xmm3
movss  %xmm3,-0x64(%rsp)
add    $0x4,%rsi
test   $0x10000,%ebp
je     134d <load_store_sf+0x24d>
movss  (%rsi),%xmm3
movss  %xmm3,-0x60(%rsp)
add    $0x4,%rsi
test   $0x20000,%ebp
je     1359 <load_store_sf+0x259>
movss  (%rsi),%xmm3
movss  %xmm3,-0x5c(%rsp)
add    $0x4,%rsi
test   $0x40000,%ebp
je     1365 <load_store_sf+0x265>
movss  (%rsi),%xmm3
movss  %xmm3,-0x58(%rsp)
add    $0x4,%rsi
test   $0x80000,%ebp
je     1371 <load_store_sf+0x271>
movss  (%rsi),%xmm3
movss  %xmm3,-0x54(%rsp)
add    $0x4,%rsi
test   $0x100000,%ebp
je     137d <load_store_sf+0x27d>
movss  (%rsi),%xmm3
movss  %xmm3,-0x50(%rsp)
add    $0x4,%rsi
test   $0x200000,%ebp
je     1389 <load_store_sf+0x289>
movss  (%rsi),%xmm3
movss  %xmm3,-0x4c(%rsp)
add    $0x4,%rsi
test   $0x400000,%ebp
je     1395 <load_store_sf+0x295>
movss  (%rsi),%xmm3
movss  %xmm3,-0x48(%rsp)
add    $0x4,%rsi
test   $0x800000,%ebp
je     13a1 <load_store_sf+0x2a1>
movss  (%rsi),%xmm3
movss  %xmm3,-0x44(%rsp)
add    $0x4,%rsi
test   $0x1000000,%ebp
je     13ad <load_store_sf+0x2ad>
movss  (%rsi),%xmm3
movss  %xmm3,-0x40(%rsp)
add    $0x4,%rsi
test   $0x2000000,%ebp
je     13b9 <load_store_sf+0x2b9>
movss  (%rsi),%xmm3
movss  %xmm3,-0x3c(%rsp)
add    $0x4,%rsi
test   $0x4000000,%ebp
je     13c5 <load_store_sf+0x2c5>
movss  (%rsi),%xmm3
movss  %xmm3,-0x38(%rsp)
add    $0x4,%rsi
test   $0x8000000,%ebp
je     13d1 <load_store_sf+0x2d1>
movss  (%rsi),%xmm3
movss  %xmm3,-0x34(%rsp)
add    $0x4,%rsi
test   $0x10000000,%ebp
je     13dd <load_store_sf+0x2dd>
movss  (%rsi),%xmm3
movss  %xmm3,-0x30(%rsp)
add    $0x4,%rsi
test   $0x20000000,%ebp
je     13e9 <load_store_sf+0x2e9>
movss  (%rsi),%xmm3
movss  %xmm3,-0x2c(%rsp)
add    $0x4,%rsi
test   $0x40000000,%ebp
je     13f5 <load_store_sf+0x2f5>
movss  (%rsi),%xmm3
movss  %xmm3,-0x28(%rsp)
add    $0x4,%rsi
test   $0x80000000,%ebp
je     1401 <load_store_sf+0x301>
movss  (%rsi),%xmm3
movss  %xmm3,-0x24(%rsp)
add    $0x4,%rsi
test   %rax,%rbp
je     140a <load_store_sf+0x30a>
movss  (%rsi),%xmm3
movss  %xmm3,-0x20(%rsp)
add    $0x4,%rsi
test   %r13,%rbp
je     1413 <load_store_sf+0x313>
movss  (%rsi),%xmm3
movss  %xmm3,-0x1c(%rsp)
add    $0x4,%rsi
test   %r12,%rbp
je     141c <load_store_sf+0x31c>
movss  (%rsi),%xmm3
movss  %xmm3,-0x18(%rsp)
add    $0x4,%rsi
test   %r15,%rbp
je     1425 <load_store_sf+0x325>
movss  (%rsi),%xmm3
movss  %xmm3,-0x14(%rsp)
add    $0x4,%rsi
test   %r14,%rbp
je     142e <load_store_sf+0x32e>
movss  (%rsi),%xmm3
movss  %xmm3,-0x10(%rsp)
add    $0x4,%rsi
test   %r11,%rbp
je     1437 <load_store_sf+0x337>
movss  (%rsi),%xmm3
movss  %xmm3,-0xc(%rsp)
add    $0x4,%rsi
test   %r10,%rbp
je     1440 <load_store_sf+0x340>
movss  (%rsi),%xmm3
movss  %xmm3,-0x8(%rsp)
add    $0x4,%rsi
test   %r9,%rbp
jne    1445 <load_store_sf+0x345>
jmp    1453 <load_store_sf+0x353>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  %xmm0,(%rdx)
add    $0x4,%rdx
test   $0x2,%bpl
je     146b <load_store_sf+0x36b>
movss  %xmm2,(%rdx)
add    $0x4,%rdx
test   $0x4,%bpl
je     1475 <load_store_sf+0x375>
movss  %xmm15,(%rdx)
add    $0x4,%rdx
test   $0x8,%bpl
je     147f <load_store_sf+0x37f>
movss  %xmm14,(%rdx)
add    $0x4,%rdx
test   $0x10,%bpl
je     1489 <load_store_sf+0x389>
movss  %xmm13,(%rdx)
add    $0x4,%rdx
test   $0x20,%bpl
je     1493 <load_store_sf+0x393>
movss  %xmm12,(%rdx)
add    $0x4,%rdx
test   $0x40,%bpl
je     149d <load_store_sf+0x39d>
movss  %xmm11,(%rdx)
add    $0x4,%rdx
test   $0x80,%bpl
je     14a7 <load_store_sf+0x3a7>
movss  %xmm10,(%rdx)
add    $0x4,%rdx
test   $0x100,%ebp
je     14b3 <load_store_sf+0x3b3>
movss  %xmm9,(%rdx)
add    $0x4,%rdx
test   $0x200,%ebp
je     14bf <load_store_sf+0x3bf>
movss  %xmm8,(%rdx)
add    $0x4,%rdx
test   $0x400,%ebp
je     14cb <load_store_sf+0x3cb>
movss  %xmm1,(%rdx)
add    $0x4,%rdx
test   $0x800,%ebp
je     14d7 <load_store_sf+0x3d7>
movss  %xmm7,(%rdx)
add    $0x4,%rdx
test   $0x1000,%ebp
je     14e3 <load_store_sf+0x3e3>
movss  %xmm6,(%rdx)
add    $0x4,%rdx
test   $0x2000,%ebp
je     14ef <load_store_sf+0x3ef>
movss  %xmm5,(%rdx)
add    $0x4,%rdx
test   $0x4000,%ebp
je     14fb <load_store_sf+0x3fb>
movss  %xmm4,(%rdx)
add    $0x4,%rdx
test   $0x8000,%ebp
je     1507 <load_store_sf+0x407>
movss  -0x64(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x10000,%ebp
je     1513 <load_store_sf+0x413>
movss  -0x60(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x20000,%ebp
je     151f <load_store_sf+0x41f>
movss  -0x5c(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x40000,%ebp
je     152b <load_store_sf+0x42b>
movss  -0x58(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x80000,%ebp
je     1537 <load_store_sf+0x437>
movss  -0x54(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x100000,%ebp
je     1543 <load_store_sf+0x443>
movss  -0x50(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x200000,%ebp
je     154f <load_store_sf+0x44f>
movss  -0x4c(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x400000,%ebp
je     155b <load_store_sf+0x45b>
movss  -0x48(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x800000,%ebp
je     1567 <load_store_sf+0x467>
movss  -0x44(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x1000000,%ebp
je     1573 <load_store_sf+0x473>
movss  -0x40(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x2000000,%ebp
je     157f <load_store_sf+0x47f>
movss  -0x3c(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x4000000,%ebp
je     158b <load_store_sf+0x48b>
movss  -0x38(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x8000000,%ebp
je     1597 <load_store_sf+0x497>
movss  -0x34(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x10000000,%ebp
je     15a3 <load_store_sf+0x4a3>
movss  -0x30(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x20000000,%ebp
je     15af <load_store_sf+0x4af>
movss  -0x2c(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x40000000,%ebp
je     15bb <load_store_sf+0x4bb>
movss  -0x28(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   $0x80000000,%ebp
je     15c7 <load_store_sf+0x4c7>
movss  -0x24(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   %rax,%rbp
je     15d0 <load_store_sf+0x4d0>
movss  -0x20(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   %r13,%rbp
je     15d9 <load_store_sf+0x4d9>
movss  -0x1c(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   %r12,%rbp
je     15e2 <load_store_sf+0x4e2>
movss  -0x18(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   %r15,%rbp
je     15eb <load_store_sf+0x4eb>
movss  -0x14(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   %r14,%rbp
je     15f4 <load_store_sf+0x4f4>
movss  -0x10(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   %r11,%rbp
je     15fd <load_store_sf+0x4fd>
movss  -0xc(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   %r10,%rbp
je     1606 <load_store_sf+0x506>
movss  -0x8(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
test   %r9,%rbp
je     1280 <load_store_sf+0x180>
movss  -0x4(%rsp),%xmm3
movss  %xmm3,(%rdx)
add    $0x4,%rdx
jmp    1280 <load_store_sf+0x180>
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
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xorps  %xmm0,%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
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* %53
br label %54
54: ; preds = %705, %5
%55 = load i64, i64* %53
%56 = load i64, i64* %6
%57 = icmp ult i64 %55, %56
br i1 %57, label %58, label %708
58: ; preds = %54
%59 = load i64*, i64** %9
%60 = getelementptr inbounds i64, i64* %59, i32 1
store i64* %60, i64** %9
%61 = load i64, i64* %59
store i64 %61, i64* %51
%62 = load i64, i64* %51
%63 = and i64 %62, 1
%64 = icmp ne i64 %63, 0
br i1 %64, label %65, label %69
65: ; preds = %58
%66 = load float*, float** %7
%67 = getelementptr inbounds float, float* %66, i32 1
store float* %67, float** %7
%68 = load float, float* %66
store float %68, float* %11
br label %69
69: ; preds = %65, %58
%70 = load i64, i64* %51
%71 = and i64 %70, 2
%72 = icmp ne i64 %71, 0
br i1 %72, label %73, label %77
73: ; preds = %69
%74 = load float*, float** %7
%75 = getelementptr inbounds float, float* %74, i32 1
store float* %75, float** %7
%76 = load float, float* %74
store float %76, float* %12
br label %77
77: ; preds = %73, %69
%78 = load i64, i64* %51
%79 = and i64 %78, 4
%80 = icmp ne i64 %79, 0
br i1 %80, label %81, label %85
81: ; preds = %77
%82 = load float*, float** %7
%83 = getelementptr inbounds float, float* %82, i32 1
store float* %83, float** %7
%84 = load float, float* %82
store float %84, float* %13
br label %85
85: ; preds = %81, %77
%86 = load i64, i64* %51
%87 = and i64 %86, 8
%88 = icmp ne i64 %87, 0
br i1 %88, label %89, label %93
89: ; preds = %85
%90 = load float*, float** %7
%91 = getelementptr inbounds float, float* %90, i32 1
store float* %91, float** %7
%92 = load float, float* %90
store float %92, float* %14
br label %93
93: ; preds = %89, %85
%94 = load i64, i64* %51
%95 = and i64 %94, 16
%96 = icmp ne i64 %95, 0
br i1 %96, label %97, label %101
97: ; preds = %93
%98 = load float*, float** %7
%99 = getelementptr inbounds float, float* %98, i32 1
store float* %99, float** %7
%100 = load float, float* %98
store float %100, float* %15
br label %101
101: ; preds = %97, %93
%102 = load i64, i64* %51
%103 = and i64 %102, 32
%104 = icmp ne i64 %103, 0
br i1 %104, label %105, label %109
105: ; preds = %101
%106 = load float*, float** %7
%107 = getelementptr inbounds float, float* %106, i32 1
store float* %107, float** %7
%108 = load float, float* %106
store float %108, float* %16
br label %109
109: ; preds = %105, %101
%110 = load i64, i64* %51
%111 = and i64 %110, 64
%112 = icmp ne i64 %111, 0
br i1 %112, label %113, label %117
113: ; preds = %109
%114 = load float*, float** %7
%115 = getelementptr inbounds float, float* %114, i32 1
store float* %115, float** %7
%116 = load float, float* %114
store float %116, float* %17
br label %117
117: ; preds = %113, %109
%118 = load i64, i64* %51
%119 = and i64 %118, 128
%120 = icmp ne i64 %119, 0
br i1 %120, label %121, label %125
121: ; preds = %117
%122 = load float*, float** %7
%123 = getelementptr inbounds float, float* %122, i32 1
store float* %123, float** %7
%124 = load float, float* %122
store float %124, float* %18
br label %125
125: ; preds = %121, %117
%126 = load i64, i64* %51
%127 = and i64 %126, 256
%128 = icmp ne i64 %127, 0
br i1 %128, label %129, label %133
129: ; preds = %125
%130 = load float*, float** %7
%131 = getelementptr inbounds float, float* %130, i32 1
store float* %131, float** %7
%132 = load float, float* %130
store float %132, float* %19
br label %133
133: ; preds = %129, %125
%134 = load i64, i64* %51
%135 = and i64 %134, 512
%136 = icmp ne i64 %135, 0
br i1 %136, label %137, label %141
137: ; preds = %133
%138 = load float*, float** %7
%139 = getelementptr inbounds float, float* %138, i32 1
store float* %139, float** %7
%140 = load float, float* %138
store float %140, float* %20
br label %141
141: ; preds = %137, %133
%142 = load i64, i64* %51
%143 = and i64 %142, 1024
%144 = icmp ne i64 %143, 0
br i1 %144, label %145, label %149
145: ; preds = %141
%146 = load float*, float** %7
%147 = getelementptr inbounds float, float* %146, i32 1
store float* %147, float** %7
%148 = load float, float* %146
store float %148, float* %21
br label %149
149: ; preds = %145, %141
%150 = load i64, i64* %51
%151 = and i64 %150, 2048
%152 = icmp ne i64 %151, 0
br i1 %152, label %153, label %157
153: ; preds = %149
%154 = load float*, float** %7
%155 = getelementptr inbounds float, float* %154, i32 1
store float* %155, float** %7
%156 = load float, float* %154
store float %156, float* %22
br label %157
157: ; preds = %153, %149
%158 = load i64, i64* %51
%159 = and i64 %158, 4096
%160 = icmp ne i64 %159, 0
br i1 %160, label %161, label %165
161: ; preds = %157
%162 = load float*, float** %7
%163 = getelementptr inbounds float, float* %162, i32 1
store float* %163, float** %7
%164 = load float, float* %162
store float %164, float* %23
br label %165
165: ; preds = %161, %157
%166 = load i64, i64* %51
%167 = and i64 %166, 8192
%168 = icmp ne i64 %167, 0
br i1 %168, label %169, label %173
169: ; preds = %165
%170 = load float*, float** %7
%171 = getelementptr inbounds float, float* %170, i32 1
store float* %171, float** %7
%172 = load float, float* %170
store float %172, float* %24
br label %173
173: ; preds = %169, %165
%174 = load i64, i64* %51
%175 = and i64 %174, 16384
%176 = icmp ne i64 %175, 0
br i1 %176, label %177, label %181
177: ; preds = %173
%178 = load float*, float** %7
%179 = getelementptr inbounds float, float* %178, i32 1
store float* %179, float** %7
%180 = load float, float* %178
store float %180, float* %25
br label %181
181: ; preds = %177, %173
%182 = load i64, i64* %51
%183 = and i64 %182, 32768
%184 = icmp ne i64 %183, 0
br i1 %184, label %185, label %189
185: ; preds = %181
%186 = load float*, float** %7
%187 = getelementptr inbounds float, float* %186, i32 1
store float* %187, float** %7
%188 = load float, float* %186
store float %188, float* %26
br label %189
189: ; preds = %185, %181
%190 = load i64, i64* %51
%191 = and i64 %190, 65536
%192 = icmp ne i64 %191, 0
br i1 %192, label %193, label %197
193: ; preds = %189
%194 = load float*, float** %7
%195 = getelementptr inbounds float, float* %194, i32 1
store float* %195, float** %7
%196 = load float, float* %194
store float %196, float* %27
br label %197
197: ; preds = %193, %189
%198 = load i64, i64* %51
%199 = and i64 %198, 131072
%200 = icmp ne i64 %199, 0
br i1 %200, label %201, label %205
201: ; preds = %197
%202 = load float*, float** %7
%203 = getelementptr inbounds float, float* %202, i32 1
store float* %203, float** %7
%204 = load float, float* %202
store float %204, float* %28
br label %205
205: ; preds = %201, %197
%206 = load i64, i64* %51
%207 = and i64 %206, 262144
%208 = icmp ne i64 %207, 0
br i1 %208, label %209, label %213
209: ; preds = %205
%210 = load float*, float** %7
%211 = getelementptr inbounds float, float* %210, i32 1
store float* %211, float** %7
%212 = load float, float* %210
store float %212, float* %29
br label %213
213: ; preds = %209, %205
%214 = load i64, i64* %51
%215 = and i64 %214, 524288
%216 = icmp ne i64 %215, 0
br i1 %216, label %217, label %221
217: ; preds = %213
%218 = load float*, float** %7
%219 = getelementptr inbounds float, float* %218, i32 1
store float* %219, float** %7
%220 = load float, float* %218
store float %220, float* %30
br label %221
221: ; preds = %217, %213
%222 = load i64, i64* %51
%223 = and i64 %222, 1048576
%224 = icmp ne i64 %223, 0
br i1 %224, label %225, label %229
225: ; preds = %221
%226 = load float*, float** %7
%227 = getelementptr inbounds float, float* %226, i32 1
store float* %227, float** %7
%228 = load float, float* %226
store float %228, float* %31
br label %229
229: ; preds = %225, %221
%230 = load i64, i64* %51
%231 = and i64 %230, 2097152
%232 = icmp ne i64 %231, 0
br i1 %232, label %233, label %237
233: ; preds = %229
%234 = load float*, float** %7
%235 = getelementptr inbounds float, float* %234, i32 1
store float* %235, float** %7
%236 = load float, float* %234
store float %236, float* %32
br label %237
237: ; preds = %233, %229
%238 = load i64, i64* %51
%239 = and i64 %238, 4194304
%240 = icmp ne i64 %239, 0
br i1 %240, label %241, label %245
241: ; preds = %237
%242 = load float*, float** %7
%243 = getelementptr inbounds float, float* %242, i32 1
store float* %243, float** %7
%244 = load float, float* %242
store float %244, float* %33
br label %245
245: ; preds = %241, %237
%246 = load i64, i64* %51
%247 = and i64 %246, 8388608
%248 = icmp ne i64 %247, 0
br i1 %248, label %249, label %253
249: ; preds = %245
%250 = load float*, float** %7
%251 = getelementptr inbounds float, float* %250, i32 1
store float* %251, float** %7
%252 = load float, float* %250
store float %252, float* %34
br label %253
253: ; preds = %249, %245
%254 = load i64, i64* %51
%255 = and i64 %254, 16777216
%256 = icmp ne i64 %255, 0
br i1 %256, label %257, label %261
257: ; preds = %253
%258 = load float*, float** %7
%259 = getelementptr inbounds float, float* %258, i32 1
store float* %259, float** %7
%260 = load float, float* %258
store float %260, float* %35
br label %261
261: ; preds = %257, %253
%262 = load i64, i64* %51
%263 = and i64 %262, 33554432
%264 = icmp ne i64 %263, 0
br i1 %264, label %265, label %269
265: ; preds = %261
%266 = load float*, float** %7
%267 = getelementptr inbounds float, float* %266, i32 1
store float* %267, float** %7
%268 = load float, float* %266
store float %268, float* %36
br label %269
269: ; preds = %265, %261
%270 = load i64, i64* %51
%271 = and i64 %270, 67108864
%272 = icmp ne i64 %271, 0
br i1 %272, label %273, label %277
273: ; preds = %269
%274 = load float*, float** %7
%275 = getelementptr inbounds float, float* %274, i32 1
store float* %275, float** %7
%276 = load float, float* %274
store float %276, float* %37
br label %277
277: ; preds = %273, %269
%278 = load i64, i64* %51
%279 = and i64 %278, 134217728
%280 = icmp ne i64 %279, 0
br i1 %280, label %281, label %285
281: ; preds = %277
%282 = load float*, float** %7
%283 = getelementptr inbounds float, float* %282, i32 1
store float* %283, float** %7
%284 = load float, float* %282
store float %284, float* %38
br label %285
285: ; preds = %281, %277
%286 = load i64, i64* %51
%287 = and i64 %286, 268435456
%288 = icmp ne i64 %287, 0
br i1 %288, label %289, label %293
289: ; preds = %285
%290 = load float*, float** %7
%291 = getelementptr inbounds float, float* %290, i32 1
store float* %291, float** %7
%292 = load float, float* %290
store float %292, float* %39
br label %293
293: ; preds = %289, %285
%294 = load i64, i64* %51
%295 = and i64 %294, 536870912
%296 = icmp ne i64 %295, 0
br i1 %296, label %297, label %301
297: ; preds = %293
%298 = load float*, float** %7
%299 = getelementptr inbounds float, float* %298, i32 1
store float* %299, float** %7
%300 = load float, float* %298
store float %300, float* %40
br label %301
301: ; preds = %297, %293
%302 = load i64, i64* %51
%303 = and i64 %302, 1073741824
%304 = icmp ne i64 %303, 0
br i1 %304, label %305, label %309
305: ; preds = %301
%306 = load float*, float** %7
%307 = getelementptr inbounds float, float* %306, i32 1
store float* %307, float** %7
%308 = load float, float* %306
store float %308, float* %41
br label %309
309: ; preds = %305, %301
%310 = load i64, i64* %51
%311 = and i64 %310, 2147483648
%312 = icmp ne i64 %311, 0
br i1 %312, label %313, label %317
313: ; preds = %309
%314 = load float*, float** %7
%315 = getelementptr inbounds float, float* %314, i32 1
store float* %315, float** %7
%316 = load float, float* %314
store float %316, float* %42
br label %317
317: ; preds = %313, %309
%318 = load i64, i64* %51
%319 = and i64 %318, 4294967296
%320 = icmp ne i64 %319, 0
br i1 %320, label %321, label %325
321: ; preds = %317
%322 = load float*, float** %7
%323 = getelementptr inbounds float, float* %322, i32 1
store float* %323, float** %7
%324 = load float, float* %322
store float %324, float* %43
br label %325
325: ; preds = %321, %317
%326 = load i64, i64* %51
%327 = and i64 %326, 8589934592
%328 = icmp ne i64 %327, 0
br i1 %328, label %329, label %333
329: ; preds = %325
%330 = load float*, float** %7
%331 = getelementptr inbounds float, float* %330, i32 1
store float* %331, float** %7
%332 = load float, float* %330
store float %332, float* %44
br label %333
333: ; preds = %329, %325
%334 = load i64, i64* %51
%335 = and i64 %334, 17179869184
%336 = icmp ne i64 %335, 0
br i1 %336, label %337, label %341
337: ; preds = %333
%338 = load float*, float** %7
%339 = getelementptr inbounds float, float* %338, i32 1
store float* %339, float** %7
%340 = load float, float* %338
store float %340, float* %45
br label %341
341: ; preds = %337, %333
%342 = load i64, i64* %51
%343 = and i64 %342, 34359738368
%344 = icmp ne i64 %343, 0
br i1 %344, label %345, label %349
345: ; preds = %341
%346 = load float*, float** %7
%347 = getelementptr inbounds float, float* %346, i32 1
store float* %347, float** %7
%348 = load float, float* %346
store float %348, float* %46
br label %349
349: ; preds = %345, %341
%350 = load i64, i64* %51
%351 = and i64 %350, 68719476736
%352 = icmp ne i64 %351, 0
br i1 %352, label %353, label %357
353: ; preds = %349
%354 = load float*, float** %7
%355 = getelementptr inbounds float, float* %354, i32 1
store float* %355, float** %7
%356 = load float, float* %354
store float %356, float* %47
br label %357
357: ; preds = %353, %349
%358 = load i64, i64* %51
%359 = and i64 %358, 137438953472
%360 = icmp ne i64 %359, 0
br i1 %360, label %361, label %365
361: ; preds = %357
%362 = load float*, float** %7
%363 = getelementptr inbounds float, float* %362, i32 1
store float* %363, float** %7
%364 = load float, float* %362
store float %364, float* %48
br label %365
365: ; preds = %361, %357
%366 = load i64, i64* %51
%367 = and i64 %366, 274877906944
%368 = icmp ne i64 %367, 0
br i1 %368, label %369, label %373
369: ; preds = %365
%370 = load float*, float** %7
%371 = getelementptr inbounds float, float* %370, i32 1
store float* %371, float** %7
%372 = load float, float* %370
store float %372, float* %49
br label %373
373: ; preds = %369, %365
%374 = load i64, i64* %51
%375 = and i64 %374, 549755813888
%376 = icmp ne i64 %375, 0
br i1 %376, label %377, label %381
377: ; preds = %373
%378 = load float*, float** %7
%379 = getelementptr inbounds float, float* %378, i32 1
store float* %379, float** %7
%380 = load float, float* %378
store float %380, float* %50
br label %381
381: ; preds = %377, %373
%382 = load i64*, i64** %10
%383 = getelementptr inbounds i64, i64* %382, i32 1
store i64* %383, i64** %10
%384 = load i64, i64* %382
store i64 %384, i64* %52
%385 = load i64, i64* %52
%386 = and i64 %385, 1
%387 = icmp ne i64 %386, 0
br i1 %387, label %388, label %392
388: ; preds = %381
%389 = load float, float* %11
%390 = load float*, float** %8
%391 = getelementptr inbounds float, float* %390, i32 1
store float* %391, float** %8
store float %389, float* %390
br label %392
392: ; preds = %388, %381
%393 = load i64, i64* %52
%394 = and i64 %393, 2
%395 = icmp ne i64 %394, 0
br i1 %395, label %396, label %400
396: ; preds = %392
%397 = load float, float* %12
%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, %392
%401 = load i64, i64* %52
%402 = and i64 %401, 4
%403 = icmp ne i64 %402, 0
br i1 %403, label %404, label %408
404: ; preds = %400
%405 = load float, float* %13
%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* %52
%410 = and i64 %409, 8
%411 = icmp ne i64 %410, 0
br i1 %411, label %412, label %416
412: ; preds = %408
%413 = load float, float* %14
%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* %52
%418 = and i64 %417, 16
%419 = icmp ne i64 %418, 0
br i1 %419, label %420, label %424
420: ; preds = %416
%421 = load float, float* %15
%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* %52
%426 = and i64 %425, 32
%427 = icmp ne i64 %426, 0
br i1 %427, label %428, label %432
428: ; preds = %424
%429 = load float, float* %16
%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* %52
%434 = and i64 %433, 64
%435 = icmp ne i64 %434, 0
br i1 %435, label %436, label %440
436: ; preds = %432
%437 = load float, float* %17
%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* %52
%442 = and i64 %441, 128
%443 = icmp ne i64 %442, 0
br i1 %443, label %444, label %448
444: ; preds = %440
%445 = load float, float* %18
%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* %52
%450 = and i64 %449, 256
%451 = icmp ne i64 %450, 0
br i1 %451, label %452, label %456
452: ; preds = %448
%453 = load float, float* %19
%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* %52
%458 = and i64 %457, 512
%459 = icmp ne i64 %458, 0
br i1 %459, label %460, label %464
460: ; preds = %456
%461 = load float, float* %20
%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* %52
%466 = and i64 %465, 1024
%467 = icmp ne i64 %466, 0
br i1 %467, label %468, label %472
468: ; preds = %464
%469 = load float, float* %21
%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* %52
%474 = and i64 %473, 2048
%475 = icmp ne i64 %474, 0
br i1 %475, label %476, label %480
476: ; preds = %472
%477 = load float, float* %22
%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* %52
%482 = and i64 %481, 4096
%483 = icmp ne i64 %482, 0
br i1 %483, label %484, label %488
484: ; preds = %480
%485 = load float, float* %23
%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* %52
%490 = and i64 %489, 8192
%491 = icmp ne i64 %490, 0
br i1 %491, label %492, label %496
492: ; preds = %488
%493 = load float, float* %24
%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* %52
%498 = and i64 %497, 16384
%499 = icmp ne i64 %498, 0
br i1 %499, label %500, label %504
500: ; preds = %496
%501 = load float, float* %25
%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* %52
%506 = and i64 %505, 32768
%507 = icmp ne i64 %506, 0
br i1 %507, label %508, label %512
508: ; preds = %504
%509 = load float, float* %26
%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* %52
%514 = and i64 %513, 65536
%515 = icmp ne i64 %514, 0
br i1 %515, label %516, label %520
516: ; preds = %512
%517 = load float, float* %27
%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* %52
%522 = and i64 %521, 131072
%523 = icmp ne i64 %522, 0
br i1 %523, label %524, label %528
524: ; preds = %520
%525 = load float, float* %28
%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* %52
%530 = and i64 %529, 262144
%531 = icmp ne i64 %530, 0
br i1 %531, label %532, label %536
532: ; preds = %528
%533 = load float, float* %29
%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* %52
%538 = and i64 %537, 524288
%539 = icmp ne i64 %538, 0
br i1 %539, label %540, label %544
540: ; preds = %536
%541 = load float, float* %30
%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* %52
%546 = and i64 %545, 1048576
%547 = icmp ne i64 %546, 0
br i1 %547, label %548, label %552
548: ; preds = %544
%549 = load float, float* %31
%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* %52
%554 = and i64 %553, 2097152
%555 = icmp ne i64 %554, 0
br i1 %555, label %556, label %560
556: ; preds = %552
%557 = load float, float* %32
%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* %52
%562 = and i64 %561, 4194304
%563 = icmp ne i64 %562, 0
br i1 %563, label %564, label %568
564: ; preds = %560
%565 = load float, float* %33
%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* %52
%570 = and i64 %569, 8388608
%571 = icmp ne i64 %570, 0
br i1 %571, label %572, label %576
572: ; preds = %568
%573 = load float, float* %34
%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* %52
%578 = and i64 %577, 16777216
%579 = icmp ne i64 %578, 0
br i1 %579, label %580, label %584
580: ; preds = %576
%581 = load float, float* %35
%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* %52
%586 = and i64 %585, 33554432
%587 = icmp ne i64 %586, 0
br i1 %587, label %588, label %592
588: ; preds = %584
%589 = load float, float* %36
%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* %52
%594 = and i64 %593, 67108864
%595 = icmp ne i64 %594, 0
br i1 %595, label %596, label %600
596: ; preds = %592
%597 = load float, float* %37
%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* %52
%602 = and i64 %601, 134217728
%603 = icmp ne i64 %602, 0
br i1 %603, label %604, label %608
604: ; preds = %600
%605 = load float, float* %38
%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* %52
%610 = and i64 %609, 268435456
%611 = icmp ne i64 %610, 0
br i1 %611, label %612, label %616
612: ; preds = %608
%613 = load float, float* %39
%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* %52
%618 = and i64 %617, 536870912
%619 = icmp ne i64 %618, 0
br i1 %619, label %620, label %624
620: ; preds = %616
%621 = load float, float* %40
%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* %52
%626 = and i64 %625, 1073741824
%627 = icmp ne i64 %626, 0
br i1 %627, label %628, label %632
628: ; preds = %624
%629 = load float, float* %41
%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* %52
%634 = and i64 %633, 2147483648
%635 = icmp ne i64 %634, 0
br i1 %635, label %636, label %640
636: ; preds = %632
%637 = load float, float* %42
%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* %52
%642 = and i64 %641, 4294967296
%643 = icmp ne i64 %642, 0
br i1 %643, label %644, label %648
644: ; preds = %640
%645 = load float, float* %43
%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* %52
%650 = and i64 %649, 8589934592
%651 = icmp ne i64 %650, 0
br i1 %651, label %652, label %656
652: ; preds = %648
%653 = load float, float* %44
%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* %52
%658 = and i64 %657, 17179869184
%659 = icmp ne i64 %658, 0
br i1 %659, label %660, label %664
660: ; preds = %656
%661 = load float, float* %45
%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* %52
%666 = and i64 %665, 34359738368
%667 = icmp ne i64 %666, 0
br i1 %667, label %668, label %672
668: ; preds = %664
%669 = load float, float* %46
%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* %52
%674 = and i64 %673, 68719476736
%675 = icmp ne i64 %674, 0
br i1 %675, label %676, label %680
676: ; preds = %672
%677 = load float, float* %47
%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* %52
%682 = and i64 %681, 137438953472
%683 = icmp ne i64 %682, 0
br i1 %683, label %684, label %688
684: ; preds = %680
%685 = load float, float* %48
%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* %52
%690 = and i64 %689, 274877906944
%691 = icmp ne i64 %690, 0
br i1 %691, label %692, label %696
692: ; preds = %688
%693 = load float, float* %49
%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* %52
%698 = and i64 %697, 549755813888
%699 = icmp ne i64 %698, 0
br i1 %699, label %700, label %704
700: ; preds = %696
%701 = load float, float* %50
%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
br label %705
705: ; preds = %704
%706 = load i64, i64* %53
%707 = add i64 %706, 1
store i64 %707, i64* %53
br label %54
708: ; preds = %54
%709 = load float, float* %11
%710 = load float, float* %12
%711 = fadd float %709, %710
%712 = load float, float* %13
%713 = fadd float %711, %712
%714 = load float, float* %14
%715 = fadd float %713, %714
%716 = load float, float* %15
%717 = fadd float %715, %716
%718 = load float, float* %16
%719 = fadd float %717, %718
%720 = load float, float* %17
%721 = fadd float %719, %720
%722 = load float, float* %18
%723 = fadd float %721, %722
%724 = load float, float* %19
%725 = fadd float %723, %724
%726 = load float, float* %20
%727 = fadd float %725, %726
%728 = load float, float* %21
%729 = fadd float %727, %728
%730 = load float, float* %22
%731 = fadd float %729, %730
%732 = load float, float* %23
%733 = fadd float %731, %732
%734 = load float, float* %24
%735 = fadd float %733, %734
%736 = load float, float* %25
%737 = fadd float %735, %736
%738 = load float, float* %26
%739 = fadd float %737, %738
%740 = load float, float* %27
%741 = fadd float %739, %740
%742 = load float, float* %28
%743 = fadd float %741, %742
%744 = load float, float* %29
%745 = fadd float %743, %744
%746 = load float, float* %30
%747 = fadd float %745, %746
%748 = load float, float* %31
%749 = fadd float %747, %748
%750 = load float, float* %32
%751 = fadd float %749, %750
%752 = load float, float* %33
%753 = fadd float %751, %752
%754 = load float, float* %34
%755 = fadd float %753, %754
%756 = load float, float* %35
%757 = fadd float %755, %756
%758 = load float, float* %36
%759 = fadd float %757, %758
%760 = load float, float* %37
%761 = fadd float %759, %760
%762 = load float, float* %38
%763 = fadd float %761, %762
%764 = load float, float* %39
%765 = fadd float %763, %764
%766 = load float, float* %40
%767 = fadd float %765, %766
%768 = load float, float* %41
%769 = fadd float %767, %768
%770 = load float, float* %42
%771 = fadd float %769, %770
%772 = load float, float* %43
%773 = fadd float %771, %772
%774 = load float, float* %44
%775 = fadd float %773, %774
%776 = load float, float* %45
%777 = fadd float %775, %776
%778 = load float, float* %46
%779 = fadd float %777, %778
%780 = load float, float* %47
%781 = fadd float %779, %780
%782 = load float, float* %48
%783 = fadd float %781, %782
%784 = load float, float* %49
%785 = fadd float %783, %784
%786 = load float, float* %50
%787 = fadd float %785, %786
ret float %787
}

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