#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ free(int *);
int *malloc(int);
int *combine_ranges(int *ranges_r1, int *ranges_r2, int size_of_array) {
  int *a = malloc(size_of_array * sizeof(int));
  for (int l = 0; l < size_of_array; l++) {
    a[l] = 0;
  }
  int *starts_r1 = malloc(size_of_array / 2 * sizeof(int));
  for (int l = 0; l < size_of_array / 2; l++) {
    starts_r1[l] = ranges_r1[l * 2];
  }
  int *starts_r2 = malloc(size_of_array / 2 * sizeof(int));
  for (int l = 0; l < size_of_array / 2; l++) {
    starts_r2[l] = ranges_r2[l * 2];
  }
  int *stops_r1 = malloc(size_of_array / 2 * sizeof(int));
  for (int l = 0; l < size_of_array / 2; l++) {
    stops_r1[l] = ranges_r1[l * 2 + 1];
  }
  int *stops_r2 = malloc(size_of_array / 2 * sizeof(int));
  for (int l = 0; l < size_of_array / 2; l++) {
    stops_r2[l] = ranges_r2[l * 2 + 1];
  }
  int c_a = 0;
  int c_r1 = 0;
  int c_r2 = 0;
  while (stops_r1[c_r1] != -1 || stops_r2[c_r2] != -1) {
    if ((starts_r1[c_r1] < starts_r2[c_r2] || stops_r2[c_r2] == -1) &&
        stops_r1[c_r1] != -1) {
      a[c_a] = starts_r1[c_r1];
      if (stops_r1[c_r1] <= starts_r2[c_r2] || stops_r2[c_r2] == -1) {
        a[c_a + 1] = stops_r1[c_r1];
        c_a = c_a + 2;
        if (c_r1 < size_of_array / 2)
          c_r1++;
      } else {
        if (stops_r1[c_r1] <= stops_r2[c_r2]) {
          a[c_a + 1] = stops_r2[c_r2];
          c_a = c_a + 2;
          if (c_r1 < size_of_array / 2)
            c_r1++;
          if (c_r2 < size_of_array / 2)
            c_r2++;
        } else {
          a[c_a + 1] = stops_r1[c_r1];
          c_a = c_a + 2;
          if (c_r1 < size_of_array / 2)
            c_r1++;
          if (c_r2 < size_of_array / 2)
            c_r2++;
        }
      }
    } else if (stops_r2[c_r2] != -1) {
      a[c_a] = starts_r2[c_r2];
      if (stops_r2[c_r2] <= starts_r1[c_r1] || stops_r1[c_r1] == -1) {
        a[c_a + 1] = stops_r2[c_r2];
        c_a = c_a + 2;
        if (c_r2 < size_of_array / 2)
          c_r2++;
      } else {
        if (stops_r2[c_r2] <= stops_r1[c_r1]) {
          a[c_a + 1] = stops_r1[c_r1];
          c_a = c_a + 2;
          if (c_r1 < size_of_array / 2)
            c_r1++;
          if (c_r2 < size_of_array / 2)
            c_r2++;
        } else {
          a[c_a + 1] = stops_r2[c_r2];
          c_a = c_a + 2;
          if (c_r2 < size_of_array / 2)
            c_r2++;
          if (c_r1 < size_of_array / 2)
            c_r1++;
        }
      }
    }
  }
  free(starts_r1);
  free(stops_r1);
  free(starts_r2);
  free(stops_r2);
  return a;
}


x86 assembly (clang, -O0):
<combine_ranges>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1179 <combine_ranges+0x59>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1150 <combine_ranges+0x30>
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x74(%rbp),%eax
cmp    %ecx,%eax
jge    11e3 <combine_ranges+0xc3>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    119c <combine_ranges+0x7c>
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x78(%rbp),%eax
cmp    %ecx,%eax
jge    124d <combine_ranges+0x12d>
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1206 <combine_ranges+0xe6>
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x7c(%rbp),%eax
cmp    %ecx,%eax
jge    12ba <combine_ranges+0x19a>
mov    -0x8(%rbp),%rax
mov    -0x54(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x50(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1270 <combine_ranges+0x150>
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x80(%rbp),%eax
cmp    %ecx,%eax
jge    1327 <combine_ranges+0x207>
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x60(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    12dd <combine_ranges+0x1bd>
movl   $0x0,-0x68(%rbp)
movl   $0x0,-0x6c(%rbp)
movl   $0x0,-0x70(%rbp)
mov    -0x50(%rbp),%rcx
movslq -0x6c(%rbp),%rdx
mov    $0x1,%al
cmpl   $0xffffffff,(%rcx,%rdx,4)
mov    %al,-0x81(%rbp)
jne    136b <combine_ranges+0x24b>
mov    -0x60(%rbp),%rax
movslq -0x70(%rbp),%rcx
cmpl   $0xffffffff,(%rax,%rcx,4)
setne  %al
mov    %al,-0x81(%rbp)
mov    -0x81(%rbp),%al
test   $0x1,%al
jne    137e <combine_ranges+0x25e>
jmp    1766 <combine_ranges+0x646>
mov    -0x30(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
movslq -0x70(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jl     13ac <combine_ranges+0x28c>
mov    -0x60(%rbp),%rax
movslq -0x70(%rbp),%rcx
cmpl   $0xffffffff,(%rax,%rcx,4)
jne    1584 <combine_ranges+0x464>
mov    -0x50(%rbp),%rax
movslq -0x6c(%rbp),%rcx
cmpl   $0xffffffff,(%rax,%rcx,4)
je     1584 <combine_ranges+0x464>
mov    -0x30(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
movslq -0x70(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1402 <combine_ranges+0x2e2>
mov    -0x60(%rbp),%rax
movslq -0x70(%rbp),%rcx
cmpl   $0xffffffff,(%rax,%rcx,4)
jne    1458 <combine_ranges+0x338>
mov    -0x50(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x68(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x88(%rbp),%eax
cmp    %ecx,%eax
jge    1453 <combine_ranges+0x333>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    157f <combine_ranges+0x45f>
mov    -0x50(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x60(%rbp),%rcx
movslq -0x70(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     14f7 <combine_ranges+0x3d7>
mov    -0x60(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x68(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x8c(%rbp),%eax
cmp    %ecx,%eax
jge    14c5 <combine_ranges+0x3a5>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x90(%rbp),%eax
cmp    %ecx,%eax
jge    14f2 <combine_ranges+0x3d2>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    157a <combine_ranges+0x45a>
mov    -0x50(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x68(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x94(%rbp),%eax
cmp    %ecx,%eax
jge    1548 <combine_ranges+0x428>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x98(%rbp),%eax
cmp    %ecx,%eax
jge    1575 <combine_ranges+0x455>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    157a <combine_ranges+0x45a>
jmp    157f <combine_ranges+0x45f>
jmp    1761 <combine_ranges+0x641>
mov    -0x60(%rbp),%rax
movslq -0x70(%rbp),%rcx
cmpl   $0xffffffff,(%rax,%rcx,4)
je     175c <combine_ranges+0x63c>
mov    -0x40(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x60(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x30(%rbp),%rcx
movslq -0x6c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    15da <combine_ranges+0x4ba>
mov    -0x50(%rbp),%rax
movslq -0x6c(%rbp),%rcx
cmpl   $0xffffffff,(%rax,%rcx,4)
jne    1630 <combine_ranges+0x510>
mov    -0x60(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x68(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x9c(%rbp),%eax
cmp    %ecx,%eax
jge    162b <combine_ranges+0x50b>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1757 <combine_ranges+0x637>
mov    -0x60(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x50(%rbp),%rcx
movslq -0x6c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     16cf <combine_ranges+0x5af>
mov    -0x50(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x68(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xa0(%rbp),%eax
cmp    %ecx,%eax
jge    169d <combine_ranges+0x57d>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xa4(%rbp),%eax
cmp    %ecx,%eax
jge    16ca <combine_ranges+0x5aa>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1752 <combine_ranges+0x632>
mov    -0x60(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x68(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xa8(%rbp),%eax
cmp    %ecx,%eax
jge    1720 <combine_ranges+0x600>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xac(%rbp),%eax
cmp    %ecx,%eax
jge    174d <combine_ranges+0x62d>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1752 <combine_ranges+0x632>
jmp    1757 <combine_ranges+0x637>
jmp    175c <combine_ranges+0x63c>
jmp    1761 <combine_ranges+0x641>
jmp    133c <combine_ranges+0x21c>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x20(%rbp),%rax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<combine_ranges>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %edx,%r15d
mov    %rsi,%r13
mov    %rdi,%rbp
lea    0x0(,%r15,4),%edi
call   1050 <malloc@plt>
mov    %rax,%rbx
test   %r15d,%r15d
jle    116d <combine_ranges+0x3d>
mov    %r15d,%edx
shl    $0x2,%rdx
mov    %rbx,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
mov    %rbx,0x18(%rsp)
mov    %r15d,%ebx
shr    $0x1f,%ebx
add    %r15d,%ebx
sar    %ebx
lea    0x0(,%rbx,4),%r14d
mov    %r14d,%edi
call   1050 <malloc@plt>
mov    %rax,%r12
cmp    $0x1,%r15d
mov    %rbx,0x20(%rsp)
jle    11ac <combine_ranges+0x7c>
mov    %r14d,0xc(%rsp)
mov    %ebx,%r14d
cmp    $0x8,%ebx
ja     11c4 <combine_ranges+0x94>
xor    %eax,%eax
jmp    1210 <combine_ranges+0xe0>
mov    %r14d,%edi
call   1050 <malloc@plt>
mov    %rax,%r15
mov    %r14d,%ebx
mov    0x18(%rsp),%r14
jmp    1260 <combine_ranges+0x130>
mov    %r14d,%eax
and    $0x7,%eax
test   %rax,%rax
mov    $0x8,%ecx
cmovne %rax,%rcx
mov    %r14,%rax
sub    %rcx,%rax
xor    %ecx,%ecx
xchg   %ax,%ax
movups 0x0(%rbp,%rcx,8),%xmm0
movups 0x10(%rbp,%rcx,8),%xmm1
shufps $0x88,%xmm1,%xmm0
movups 0x20(%rbp,%rcx,8),%xmm1
movups 0x30(%rbp,%rcx,8),%xmm2
shufps $0x88,%xmm2,%xmm1
movups %xmm0,(%r12,%rcx,4)
movups %xmm1,0x10(%r12,%rcx,4)
add    $0x8,%rcx
cmp    %rcx,%rax
jne    11e0 <combine_ranges+0xb0>
mov    %r15,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x0(%rbp,%rax,8),%ecx
mov    %ecx,(%r12,%rax,4)
add    $0x1,%rax
cmp    %rax,%r14
jne    1220 <combine_ranges+0xf0>
mov    0xc(%rsp),%edi
call   1050 <malloc@plt>
mov    %rax,%r15
mov    %rbx,%rax
cmp    $0x2,%eax
jl     1257 <combine_ranges+0x127>
cmpl   $0x8,0x20(%rsp)
ja     13f6 <combine_ranges+0x2c6>
xor    %eax,%eax
jmp    1450 <combine_ranges+0x320>
mov    0x18(%rsp),%r14
mov    0xc(%rsp),%ebx
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%r13
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%rbp
mov    0x20(%rsp),%r11
movd   %r11d,%xmm0
pshufd $0x50,%xmm0,%xmm0
xorps  %xmm1,%xmm1
xor    %r8d,%r8d
jmp    12b1 <combine_ranges+0x181>
nopl   0x0(%rax,%rax,1)
mov    %r8d,%eax
or     $0x1,%eax
mov    %ecx,(%r14,%rax,4)
xor    %eax,%eax
cmp    %r11d,%r10d
setl   %al
add    %r10d,%eax
movd   %eax,%xmm2
movss  %xmm2,%xmm1
add    $0x2,%r8d
movd   %xmm1,%r10d
movslq %r10d,%rax
mov    0x0(%r13,%rax,4),%ecx
pshufd $0x55,%xmm1,%xmm2
movd   %xmm2,%r9d
movslq %r9d,%rdi
jmp    12e5 <combine_ranges+0x1b5>
mov    0x0(%rbp,%rdi,4),%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    $0xffffffff,%ebx
jne    1360 <combine_ranges+0x230>
cmp    $0xffffffff,%ecx
je     1300 <combine_ranges+0x1d0>
mov    (%r12,%rax,4),%esi
mov    (%r15,%rdi,4),%edx
cmp    %edx,%esi
jge    1317 <combine_ranges+0x1e7>
jmp    1325 <combine_ranges+0x1f5>
nopl   0x0(%rax,%rax,1)
cmpl   $0xffffffff,0x0(%rbp,%rdi,4)
je     13c4 <combine_ranges+0x294>
mov    (%r12,%rax,4),%esi
mov    (%r15,%rdi,4),%edx
cmp    %edx,%esi
jl     12cd <combine_ranges+0x19d>
mov    0x0(%rbp,%rdi,4),%ebx
cmp    $0xffffffff,%ebx
jne    12e0 <combine_ranges+0x1b0>
cmp    $0xffffffff,%ecx
je     12e0 <combine_ranges+0x1b0>
mov    %r8d,%eax
mov    %esi,(%r14,%rax,4)
cmp    %edx,%ecx
jle    1290 <combine_ranges+0x160>
mov    0x0(%rbp,%rdi,4),%eax
cmp    $0xffffffff,%eax
je     1290 <combine_ranges+0x160>
mov    %r8d,%edx
or     $0x1,%edx
cmp    %eax,%ecx
jle    13af <combine_ranges+0x27f>
mov    %ecx,(%r14,%rdx,4)
jmp    13b3 <combine_ranges+0x283>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r8d,%eax
mov    %edx,(%r14,%rax,4)
cmp    %esi,%ebx
jle    1380 <combine_ranges+0x250>
cmp    $0xffffffff,%ecx
je     1380 <combine_ranges+0x250>
mov    %r8d,%eax
or     $0x1,%eax
cmp    %ecx,%ebx
jle    13a9 <combine_ranges+0x279>
mov    %ebx,(%r14,%rax,4)
jmp    13b3 <combine_ranges+0x283>
mov    %r8d,%eax
or     $0x1,%eax
mov    %ebx,(%r14,%rax,4)
xor    %eax,%eax
cmp    %r11d,%r9d
setl   %al
add    %r9d,%eax
movd   %eax,%xmm2
punpcklqdq %xmm1,%xmm2
shufps $0xe2,%xmm1,%xmm2
movaps %xmm2,%xmm1
jmp    12ad <combine_ranges+0x17d>
mov    %ecx,(%r14,%rax,4)
jmp    13b3 <combine_ranges+0x283>
mov    %eax,(%r14,%rdx,4)
movdqa %xmm0,%xmm2
pcmpgtd %xmm1,%xmm2
psubd  %xmm2,%xmm1
jmp    12ad <combine_ranges+0x17d>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    %r14,%rax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r14d,%eax
and    $0x7,%eax
test   %rax,%rax
mov    $0x8,%ecx
cmovne %rax,%rcx
mov    %r14,%rax
sub    %rcx,%rax
xor    %ecx,%ecx
movups 0x0(%r13,%rcx,8),%xmm0
movups 0x10(%r13,%rcx,8),%xmm1
shufps $0x88,%xmm1,%xmm0
movups 0x20(%r13,%rcx,8),%xmm1
movups 0x30(%r13,%rcx,8),%xmm2
shufps $0x88,%xmm2,%xmm1
movups %xmm0,(%r15,%rcx,4)
movups %xmm1,0x10(%r15,%rcx,4)
add    $0x8,%rcx
cmp    %rcx,%rax
jne    1410 <combine_ranges+0x2e0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x0(%r13,%rax,8),%ecx
mov    %ecx,(%r15,%rax,4)
add    $0x1,%rax
cmp    %rax,%r14
jne    1450 <combine_ranges+0x320>
mov    0xc(%rsp),%edi
call   1050 <malloc@plt>
mov    %rax,0x10(%rsp)
mov    %rbx,%rax
cmp    $0x2,%eax
jl     1483 <combine_ranges+0x353>
cmpl   $0x8,0x20(%rsp)
ja     1496 <combine_ranges+0x366>
xor    %eax,%eax
jmp    14ee <combine_ranges+0x3be>
mov    0x18(%rsp),%r14
mov    0x10(%rsp),%r13
mov    0xc(%rsp),%ebx
jmp    126a <combine_ranges+0x13a>
mov    %r14d,%eax
and    $0x7,%eax
test   %rax,%rax
mov    $0x8,%ecx
cmovne %rax,%rcx
mov    %r14,%rax
sub    %rcx,%rax
xor    %ecx,%ecx
mov    0x10(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nop
movups 0x4(%rbp,%rcx,8),%xmm0
movups 0x14(%rbp,%rcx,8),%xmm1
shufps $0x88,%xmm1,%xmm0
movups 0x24(%rbp,%rcx,8),%xmm1
movups 0x34(%rbp,%rcx,8),%xmm2
shufps $0x88,%xmm2,%xmm1
movups %xmm0,(%rdx,%rcx,4)
movups %xmm1,0x10(%rdx,%rcx,4)
add    $0x8,%rcx
cmp    %rcx,%rax
jne    14c0 <combine_ranges+0x390>
mov    0x10(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x4(%rbp,%rax,8),%ecx
mov    %ecx,(%rdx,%rax,4)
add    $0x1,%rax
cmp    %rax,%r14
jne    1500 <combine_ranges+0x3d0>
mov    0xc(%rsp),%edi
call   1050 <malloc@plt>
mov    %rax,%rbp
cmp    $0x2,%ebx
jl     1530 <combine_ranges+0x400>
mov    0x20(%rsp),%r11
cmp    $0x8,%r11d
ja     1544 <combine_ranges+0x414>
xor    %eax,%eax
jmp    15a0 <combine_ranges+0x470>
mov    0x18(%rsp),%r14
mov    0x20(%rsp),%r11
mov    0x10(%rsp),%r13
jmp    1279 <combine_ranges+0x149>
mov    %r14d,%eax
and    $0x7,%eax
test   %rax,%rax
mov    $0x8,%ecx
cmovne %rax,%rcx
mov    %r14,%rax
sub    %rcx,%rax
xor    %ecx,%ecx
xchg   %ax,%ax
movups 0x4(%r13,%rcx,8),%xmm0
movups 0x14(%r13,%rcx,8),%xmm1
shufps $0x88,%xmm1,%xmm0
movups 0x24(%r13,%rcx,8),%xmm1
movups 0x34(%r13,%rcx,8),%xmm2
shufps $0x88,%xmm2,%xmm1
movups %xmm0,0x0(%rbp,%rcx,4)
movups %xmm1,0x10(%rbp,%rcx,4)
add    $0x8,%rcx
cmp    %rcx,%rax
jne    1560 <combine_ranges+0x430>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x4(%r13,%rax,8),%ecx
mov    %ecx,0x0(%rbp,%rax,4)
add    $0x1,%rax
cmp    %rax,%r14
jne    15a0 <combine_ranges+0x470>
mov    0x18(%rsp),%r14
mov    0x10(%rsp),%r13
jmp    1279 <combine_ranges+0x149>

LLVM IR (-O0):
define i32* @combine_ranges(i32* %0, i32* %1, i32 %2) {
%4 = alloca i32*
%5 = alloca i32*
%6 = alloca i32
%7 = alloca i32*
%8 = alloca i32
%9 = alloca i32*
%10 = alloca i32
%11 = alloca i32*
%12 = alloca i32
%13 = alloca i32*
%14 = alloca i32
%15 = alloca i32*
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
store i32* %0, i32** %4
store i32* %1, i32** %5
store i32 %2, i32* %6
%20 = load i32, i32* %6
%21 = sext i32 %20 to i64
%22 = mul i64 %21, 4
%23 = trunc i64 %22 to i32
%24 = call i32* @malloc(i32 %23)
store i32* %24, i32** %7
store i32 0, i32* %8
br label %25
25: ; preds = %34, %3
%26 = load i32, i32* %8
%27 = load i32, i32* %6
%28 = icmp slt i32 %26, %27
br i1 %28, label %29, label %37
29: ; preds = %25
%30 = load i32*, i32** %7
%31 = load i32, i32* %8
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds i32, i32* %30, i64 %32
store i32 0, i32* %33
br label %34
34: ; preds = %29
%35 = load i32, i32* %8
%36 = add nsw i32 %35, 1
store i32 %36, i32* %8
br label %25
37: ; preds = %25
%38 = load i32, i32* %6
%39 = sdiv i32 %38, 2
%40 = sext i32 %39 to i64
%41 = mul i64 %40, 4
%42 = trunc i64 %41 to i32
%43 = call i32* @malloc(i32 %42)
store i32* %43, i32** %9
store i32 0, i32* %10
br label %44
44: ; preds = %60, %37
%45 = load i32, i32* %10
%46 = load i32, i32* %6
%47 = sdiv i32 %46, 2
%48 = icmp slt i32 %45, %47
br i1 %48, label %49, label %63
49: ; preds = %44
%50 = load i32*, i32** %4
%51 = load i32, i32* %10
%52 = mul nsw i32 %51, 2
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds i32, i32* %50, i64 %53
%55 = load i32, i32* %54
%56 = load i32*, i32** %9
%57 = load i32, i32* %10
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds i32, i32* %56, i64 %58
store i32 %55, i32* %59
br label %60
60: ; preds = %49
%61 = load i32, i32* %10
%62 = add nsw i32 %61, 1
store i32 %62, i32* %10
br label %44
63: ; preds = %44
%64 = load i32, i32* %6
%65 = sdiv i32 %64, 2
%66 = sext i32 %65 to i64
%67 = mul i64 %66, 4
%68 = trunc i64 %67 to i32
%69 = call i32* @malloc(i32 %68)
store i32* %69, i32** %11
store i32 0, i32* %12
br label %70
70: ; preds = %86, %63
%71 = load i32, i32* %12
%72 = load i32, i32* %6
%73 = sdiv i32 %72, 2
%74 = icmp slt i32 %71, %73
br i1 %74, label %75, label %89
75: ; preds = %70
%76 = load i32*, i32** %5
%77 = load i32, i32* %12
%78 = mul nsw i32 %77, 2
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds i32, i32* %76, i64 %79
%81 = load i32, i32* %80
%82 = load i32*, i32** %11
%83 = load i32, i32* %12
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds i32, i32* %82, i64 %84
store i32 %81, i32* %85
br label %86
86: ; preds = %75
%87 = load i32, i32* %12
%88 = add nsw i32 %87, 1
store i32 %88, i32* %12
br label %70
89: ; preds = %70
%90 = load i32, i32* %6
%91 = sdiv i32 %90, 2
%92 = sext i32 %91 to i64
%93 = mul i64 %92, 4
%94 = trunc i64 %93 to i32
%95 = call i32* @malloc(i32 %94)
store i32* %95, i32** %13
store i32 0, i32* %14
br label %96
96: ; preds = %113, %89
%97 = load i32, i32* %14
%98 = load i32, i32* %6
%99 = sdiv i32 %98, 2
%100 = icmp slt i32 %97, %99
br i1 %100, label %101, label %116
101: ; preds = %96
%102 = load i32*, i32** %4
%103 = load i32, i32* %14
%104 = mul nsw i32 %103, 2
%105 = add nsw i32 %104, 1
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds i32, i32* %102, i64 %106
%108 = load i32, i32* %107
%109 = load i32*, i32** %13
%110 = load i32, i32* %14
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds i32, i32* %109, i64 %111
store i32 %108, i32* %112
br label %113
113: ; preds = %101
%114 = load i32, i32* %14
%115 = add nsw i32 %114, 1
store i32 %115, i32* %14
br label %96
116: ; preds = %96
%117 = load i32, i32* %6
%118 = sdiv i32 %117, 2
%119 = sext i32 %118 to i64
%120 = mul i64 %119, 4
%121 = trunc i64 %120 to i32
%122 = call i32* @malloc(i32 %121)
store i32* %122, i32** %15
store i32 0, i32* %16
br label %123
123: ; preds = %140, %116
%124 = load i32, i32* %16
%125 = load i32, i32* %6
%126 = sdiv i32 %125, 2
%127 = icmp slt i32 %124, %126
br i1 %127, label %128, label %143
128: ; preds = %123
%129 = load i32*, i32** %5
%130 = load i32, i32* %16
%131 = mul nsw i32 %130, 2
%132 = add nsw i32 %131, 1
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds i32, i32* %129, i64 %133
%135 = load i32, i32* %134
%136 = load i32*, i32** %15
%137 = load i32, i32* %16
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds i32, i32* %136, i64 %138
store i32 %135, i32* %139
br label %140
140: ; preds = %128
%141 = load i32, i32* %16
%142 = add nsw i32 %141, 1
store i32 %142, i32* %16
br label %123
143: ; preds = %123
store i32 0, i32* %17
store i32 0, i32* %18
store i32 0, i32* %19
br label %144
144: ; preds = %436, %143
%145 = load i32*, i32** %13
%146 = load i32, i32* %18
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds i32, i32* %145, i64 %147
%149 = load i32, i32* %148
%150 = icmp ne i32 %149, -1
br i1 %150, label %158, label %151
151: ; preds = %144
%152 = load i32*, i32** %15
%153 = load i32, i32* %19
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds i32, i32* %152, i64 %154
%156 = load i32, i32* %155
%157 = icmp ne i32 %156, -1
br label %158
158: ; preds = %151, %144
%159 = phi i1 [ true, %144 ], [ %157, %151 ]
br i1 %159, label %160, label %437
160: ; preds = %158
%161 = load i32*, i32** %9
%162 = load i32, i32* %18
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds i32, i32* %161, i64 %163
%165 = load i32, i32* %164
%166 = load i32*, i32** %11
%167 = load i32, i32* %19
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds i32, i32* %166, i64 %168
%170 = load i32, i32* %169
%171 = icmp slt i32 %165, %170
br i1 %171, label %179, label %172
172: ; preds = %160
%173 = load i32*, i32** %15
%174 = load i32, i32* %19
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds i32, i32* %173, i64 %175
%177 = load i32, i32* %176
%178 = icmp eq i32 %177, -1
br i1 %178, label %179, label %307
179: ; preds = %172, %160
%180 = load i32*, i32** %13
%181 = load i32, i32* %18
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds i32, i32* %180, i64 %182
%184 = load i32, i32* %183
%185 = icmp ne i32 %184, -1
br i1 %185, label %186, label %307
186: ; preds = %179
%187 = load i32*, i32** %9
%188 = load i32, i32* %18
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds i32, i32* %187, i64 %189
%191 = load i32, i32* %190
%192 = load i32*, i32** %7
%193 = load i32, i32* %17
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds i32, i32* %192, i64 %194
store i32 %191, i32* %195
%196 = load i32*, i32** %13
%197 = load i32, i32* %18
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds i32, i32* %196, i64 %198
%200 = load i32, i32* %199
%201 = load i32*, i32** %11
%202 = load i32, i32* %19
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds i32, i32* %201, i64 %203
%205 = load i32, i32* %204
%206 = icmp sle i32 %200, %205
br i1 %206, label %214, label %207
207: ; preds = %186
%208 = load i32*, i32** %15
%209 = load i32, i32* %19
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds i32, i32* %208, i64 %210
%212 = load i32, i32* %211
%213 = icmp eq i32 %212, -1
br i1 %213, label %214, label %235
214: ; preds = %207, %186
%215 = load i32*, i32** %13
%216 = load i32, i32* %18
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds i32, i32* %215, i64 %217
%219 = load i32, i32* %218
%220 = load i32*, i32** %7
%221 = load i32, i32* %17
%222 = add nsw i32 %221, 1
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds i32, i32* %220, i64 %223
store i32 %219, i32* %224
%225 = load i32, i32* %17
%226 = add nsw i32 %225, 2
store i32 %226, i32* %17
%227 = load i32, i32* %18
%228 = load i32, i32* %6
%229 = sdiv i32 %228, 2
%230 = icmp slt i32 %227, %229
br i1 %230, label %231, label %234
231: ; preds = %214
%232 = load i32, i32* %18
%233 = add nsw i32 %232, 1
store i32 %233, i32* %18
br label %234
234: ; preds = %231, %214
br label %306
235: ; preds = %207
%236 = load i32*, i32** %13
%237 = load i32, i32* %18
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds i32, i32* %236, i64 %238
%240 = load i32, i32* %239
%241 = load i32*, i32** %15
%242 = load i32, i32* %19
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds i32, i32* %241, i64 %243
%245 = load i32, i32* %244
%246 = icmp sle i32 %240, %245
br i1 %246, label %247, label %276
247: ; preds = %235
%248 = load i32*, i32** %15
%249 = load i32, i32* %19
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds i32, i32* %248, i64 %250
%252 = load i32, i32* %251
%253 = load i32*, i32** %7
%254 = load i32, i32* %17
%255 = add nsw i32 %254, 1
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds i32, i32* %253, i64 %256
store i32 %252, i32* %257
%258 = load i32, i32* %17
%259 = add nsw i32 %258, 2
store i32 %259, i32* %17
%260 = load i32, i32* %18
%261 = load i32, i32* %6
%262 = sdiv i32 %261, 2
%263 = icmp slt i32 %260, %262
br i1 %263, label %264, label %267
264: ; preds = %247
%265 = load i32, i32* %18
%266 = add nsw i32 %265, 1
store i32 %266, i32* %18
br label %267
267: ; preds = %264, %247
%268 = load i32, i32* %19
%269 = load i32, i32* %6
%270 = sdiv i32 %269, 2
%271 = icmp slt i32 %268, %270
br i1 %271, label %272, label %275
272: ; preds = %267
%273 = load i32, i32* %19
%274 = add nsw i32 %273, 1
store i32 %274, i32* %19
br label %275
275: ; preds = %272, %267
br label %305
276: ; preds = %235
%277 = load i32*, i32** %13
%278 = load i32, i32* %18
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds i32, i32* %277, i64 %279
%281 = load i32, i32* %280
%282 = load i32*, i32** %7
%283 = load i32, i32* %17
%284 = add nsw i32 %283, 1
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds i32, i32* %282, i64 %285
store i32 %281, i32* %286
%287 = load i32, i32* %17
%288 = add nsw i32 %287, 2
store i32 %288, i32* %17
%289 = load i32, i32* %18
%290 = load i32, i32* %6
%291 = sdiv i32 %290, 2
%292 = icmp slt i32 %289, %291
br i1 %292, label %293, label %296
293: ; preds = %276
%294 = load i32, i32* %18
%295 = add nsw i32 %294, 1
store i32 %295, i32* %18
br label %296
296: ; preds = %293, %276
%297 = load i32, i32* %19
%298 = load i32, i32* %6
%299 = sdiv i32 %298, 2
%300 = icmp slt i32 %297, %299
br i1 %300, label %301, label %304
301: ; preds = %296
%302 = load i32, i32* %19
%303 = add nsw i32 %302, 1
store i32 %303, i32* %19
br label %304
304: ; preds = %301, %296
br label %305
305: ; preds = %304, %275
br label %306
306: ; preds = %305, %234
br label %436
307: ; preds = %179, %172
%308 = load i32*, i32** %15
%309 = load i32, i32* %19
%310 = sext i32 %309 to i64
%311 = getelementptr inbounds i32, i32* %308, i64 %310
%312 = load i32, i32* %311
%313 = icmp ne i32 %312, -1
br i1 %313, label %314, label %435
314: ; preds = %307
%315 = load i32*, i32** %11
%316 = load i32, i32* %19
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds i32, i32* %315, i64 %317
%319 = load i32, i32* %318
%320 = load i32*, i32** %7
%321 = load i32, i32* %17
%322 = sext i32 %321 to i64
%323 = getelementptr inbounds i32, i32* %320, i64 %322
store i32 %319, i32* %323
%324 = load i32*, i32** %15
%325 = load i32, i32* %19
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds i32, i32* %324, i64 %326
%328 = load i32, i32* %327
%329 = load i32*, i32** %9
%330 = load i32, i32* %18
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds i32, i32* %329, i64 %331
%333 = load i32, i32* %332
%334 = icmp sle i32 %328, %333
br i1 %334, label %342, label %335
335: ; preds = %314
%336 = load i32*, i32** %13
%337 = load i32, i32* %18
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds i32, i32* %336, i64 %338
%340 = load i32, i32* %339
%341 = icmp eq i32 %340, -1
br i1 %341, label %342, label %363
342: ; preds = %335, %314
%343 = load i32*, i32** %15
%344 = load i32, i32* %19
%345 = sext i32 %344 to i64
%346 = getelementptr inbounds i32, i32* %343, i64 %345
%347 = load i32, i32* %346
%348 = load i32*, i32** %7
%349 = load i32, i32* %17
%350 = add nsw i32 %349, 1
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds i32, i32* %348, i64 %351
store i32 %347, i32* %352
%353 = load i32, i32* %17
%354 = add nsw i32 %353, 2
store i32 %354, i32* %17
%355 = load i32, i32* %19
%356 = load i32, i32* %6
%357 = sdiv i32 %356, 2
%358 = icmp slt i32 %355, %357
br i1 %358, label %359, label %362
359: ; preds = %342
%360 = load i32, i32* %19
%361 = add nsw i32 %360, 1
store i32 %361, i32* %19
br label %362
362: ; preds = %359, %342
br label %434
363: ; preds = %335
%364 = load i32*, i32** %15
%365 = load i32, i32* %19
%366 = sext i32 %365 to i64
%367 = getelementptr inbounds i32, i32* %364, i64 %366
%368 = load i32, i32* %367
%369 = load i32*, i32** %13
%370 = load i32, i32* %18
%371 = sext i32 %370 to i64
%372 = getelementptr inbounds i32, i32* %369, i64 %371
%373 = load i32, i32* %372
%374 = icmp sle i32 %368, %373
br i1 %374, label %375, label %404
375: ; preds = %363
%376 = load i32*, i32** %13
%377 = load i32, i32* %18
%378 = sext i32 %377 to i64
%379 = getelementptr inbounds i32, i32* %376, i64 %378
%380 = load i32, i32* %379
%381 = load i32*, i32** %7
%382 = load i32, i32* %17
%383 = add nsw i32 %382, 1
%384 = sext i32 %383 to i64
%385 = getelementptr inbounds i32, i32* %381, i64 %384
store i32 %380, i32* %385
%386 = load i32, i32* %17
%387 = add nsw i32 %386, 2
store i32 %387, i32* %17
%388 = load i32, i32* %18
%389 = load i32, i32* %6
%390 = sdiv i32 %389, 2
%391 = icmp slt i32 %388, %390
br i1 %391, label %392, label %395
392: ; preds = %375
%393 = load i32, i32* %18
%394 = add nsw i32 %393, 1
store i32 %394, i32* %18
br label %395
395: ; preds = %392, %375
%396 = load i32, i32* %19
%397 = load i32, i32* %6
%398 = sdiv i32 %397, 2
%399 = icmp slt i32 %396, %398
br i1 %399, label %400, label %403
400: ; preds = %395
%401 = load i32, i32* %19
%402 = add nsw i32 %401, 1
store i32 %402, i32* %19
br label %403
403: ; preds = %400, %395
br label %433
404: ; preds = %363
%405 = load i32*, i32** %15
%406 = load i32, i32* %19
%407 = sext i32 %406 to i64
%408 = getelementptr inbounds i32, i32* %405, i64 %407
%409 = load i32, i32* %408
%410 = load i32*, i32** %7
%411 = load i32, i32* %17
%412 = add nsw i32 %411, 1
%413 = sext i32 %412 to i64
%414 = getelementptr inbounds i32, i32* %410, i64 %413
store i32 %409, i32* %414
%415 = load i32, i32* %17
%416 = add nsw i32 %415, 2
store i32 %416, i32* %17
%417 = load i32, i32* %19
%418 = load i32, i32* %6
%419 = sdiv i32 %418, 2
%420 = icmp slt i32 %417, %419
br i1 %420, label %421, label %424
421: ; preds = %404
%422 = load i32, i32* %19
%423 = add nsw i32 %422, 1
store i32 %423, i32* %19
br label %424
424: ; preds = %421, %404
%425 = load i32, i32* %18
%426 = load i32, i32* %6
%427 = sdiv i32 %426, 2
%428 = icmp slt i32 %425, %427
br i1 %428, label %429, label %432
429: ; preds = %424
%430 = load i32, i32* %18
%431 = add nsw i32 %430, 1
store i32 %431, i32* %18
br label %432
432: ; preds = %429, %424
br label %433
433: ; preds = %432, %403
br label %434
434: ; preds = %433, %362
br label %435
435: ; preds = %434, %307
br label %436
436: ; preds = %435, %306
br label %144
437: ; preds = %158
%438 = load i32*, i32** %9
%439 = call i32 @free(i32* %438)
%440 = load i32*, i32** %13
%441 = call i32 @free(i32* %440)
%442 = load i32*, i32** %11
%443 = call i32 @free(i32* %442)
%444 = load i32*, i32** %15
%445 = call i32 @free(i32* %444)
%446 = load i32*, i32** %7
ret i32* %446
}

LLVM IR (-O2):
define noalias i32* @combine_ranges(i32* nocapture %0, i32* nocapture %1, i32 %2) {
%4 = shl i32 %2, 2
%5 = tail call i32* @malloc(i32 %4)
%6 = icmp sgt i32 %2, 0
br i1 %6, label %7, label %11
7: ; preds = %3
%8 = bitcast i32* %5 to i8*
%9 = zext i32 %2 to i64
%10 = shl nuw nsw i64 %9, 2
br label %11
11: ; preds = %7, %3
%12 = sdiv i32 %2, 2
%13 = shl i32 %12, 2
%14 = tail call i32* @malloc(i32 %13)
%15 = icmp sgt i32 %2, 1
br i1 %15, label %18, label %16
16: ; preds = %11
%17 = tail call i32* @malloc(i32 %13)
br label %86
18: ; preds = %11
%19 = zext i32 %12 to i64
%20 = icmp ult i32 %12, 9
br i1 %20, label %21, label %23
21: ; preds = %28, %18
%22 = phi i64 [ 0, %18 ], [ %27, %28 ]
br label %78
23: ; preds = %18
%24 = and i64 %19, 7
%25 = icmp eq i64 %24, 0
%26 = select i1 %25, i64 8, i64 %24
%27 = sub nsw i64 %19, %26
br label %28
28: ; preds = %28, %23
%29 = phi i64 [ 0, %23 ], [ %45, %28 ]
%30 = shl nuw nsw i64 %29, 1
%31 = shl i64 %29, 1
%32 = or i64 %31, 8
%33 = getelementptr inbounds i32, i32* %0, i64 %30
%34 = getelementptr inbounds i32, i32* %0, i64 %32
%35 = bitcast i32* %33 to <8 x i32>*
%36 = bitcast i32* %34 to <8 x i32>*
%37 = load <8 x i32>, <8 x i32>* %35
%38 = load <8 x i32>, <8 x i32>* %36
%39 = shufflevector <8 x i32> %37, <8 x i32> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%40 = shufflevector <8 x i32> %38, <8 x i32> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%41 = getelementptr inbounds i32, i32* %14, i64 %29
%42 = bitcast i32* %41 to <4 x i32>*
store <4 x i32> %39, <4 x i32>* %42
%43 = getelementptr inbounds i32, i32* %41, i64 4
%44 = bitcast i32* %43 to <4 x i32>*
store <4 x i32> %40, <4 x i32>* %44
%45 = add nuw i64 %29, 8
%46 = icmp eq i64 %45, %27
br i1 %46, label %21, label %28
47: ; preds = %78
%48 = tail call i32* @malloc(i32 %13)
br i1 %15, label %49, label %86
49: ; preds = %47
%50 = zext i32 %12 to i64
%51 = icmp ult i32 %12, 9
br i1 %51, label %52, label %54
52: ; preds = %59, %49
%53 = phi i64 [ 0, %49 ], [ %58, %59 ]
br label %121
54: ; preds = %49
%55 = and i64 %19, 7
%56 = icmp eq i64 %55, 0
%57 = select i1 %56, i64 8, i64 %55
%58 = sub nsw i64 %19, %57
br label %59
59: ; preds = %59, %54
%60 = phi i64 [ 0, %54 ], [ %76, %59 ]
%61 = shl nuw nsw i64 %60, 1
%62 = shl i64 %60, 1
%63 = or i64 %62, 8
%64 = getelementptr inbounds i32, i32* %1, i64 %61
%65 = getelementptr inbounds i32, i32* %1, i64 %63
%66 = bitcast i32* %64 to <8 x i32>*
%67 = bitcast i32* %65 to <8 x i32>*
%68 = load <8 x i32>, <8 x i32>* %66
%69 = load <8 x i32>, <8 x i32>* %67
%70 = shufflevector <8 x i32> %68, <8 x i32> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%71 = shufflevector <8 x i32> %69, <8 x i32> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%72 = getelementptr inbounds i32, i32* %48, i64 %60
%73 = bitcast i32* %72 to <4 x i32>*
store <4 x i32> %70, <4 x i32>* %73
%74 = getelementptr inbounds i32, i32* %72, i64 4
%75 = bitcast i32* %74 to <4 x i32>*
store <4 x i32> %71, <4 x i32>* %75
%76 = add nuw i64 %60, 8
%77 = icmp eq i64 %76, %58
br i1 %77, label %52, label %59
78: ; preds = %21, %78
%79 = phi i64 [ %84, %78 ], [ %22, %21 ]
%80 = shl nuw nsw i64 %79, 1
%81 = getelementptr inbounds i32, i32* %0, i64 %80
%82 = load i32, i32* %81
%83 = getelementptr inbounds i32, i32* %14, i64 %79
store i32 %82, i32* %83
%84 = add nuw nsw i64 %79, 1
%85 = icmp eq i64 %84, %19
br i1 %85, label %47, label %78
86: ; preds = %16, %47
%87 = phi i32* [ %48, %47 ], [ %17, %16 ]
%88 = tail call i32* @malloc(i32 %13)
br label %129
89: ; preds = %121
%90 = tail call i32* @malloc(i32 %13)
br i1 %15, label %91, label %129
91: ; preds = %89
%92 = zext i32 %12 to i64
%93 = icmp ult i32 %12, 9
br i1 %93, label %94, label %96
94: ; preds = %101, %91
%95 = phi i64 [ 0, %91 ], [ %100, %101 ]
br label %165
96: ; preds = %91
%97 = and i64 %19, 7
%98 = icmp eq i64 %97, 0
%99 = select i1 %98, i64 8, i64 %97
%100 = sub nsw i64 %19, %99
br label %101
101: ; preds = %101, %96
%102 = phi i64 [ 0, %96 ], [ %119, %101 ]
%103 = shl nuw nsw i64 %102, 1
%104 = shl i64 %102, 1
%105 = or i64 %103, 1
%106 = or i64 %104, 9
%107 = getelementptr inbounds i32, i32* %0, i64 %105
%108 = getelementptr inbounds i32, i32* %0, i64 %106
%109 = bitcast i32* %107 to <8 x i32>*
%110 = bitcast i32* %108 to <8 x i32>*
%111 = load <8 x i32>, <8 x i32>* %109
%112 = load <8 x i32>, <8 x i32>* %110
%113 = shufflevector <8 x i32> %111, <8 x i32> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%114 = shufflevector <8 x i32> %112, <8 x i32> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%115 = getelementptr inbounds i32, i32* %90, i64 %102
%116 = bitcast i32* %115 to <4 x i32>*
store <4 x i32> %113, <4 x i32>* %116
%117 = getelementptr inbounds i32, i32* %115, i64 4
%118 = bitcast i32* %117 to <4 x i32>*
store <4 x i32> %114, <4 x i32>* %118
%119 = add nuw i64 %102, 8
%120 = icmp eq i64 %119, %100
br i1 %120, label %94, label %101
121: ; preds = %52, %121
%122 = phi i64 [ %127, %121 ], [ %53, %52 ]
%123 = shl nuw nsw i64 %122, 1
%124 = getelementptr inbounds i32, i32* %1, i64 %123
%125 = load i32, i32* %124
%126 = getelementptr inbounds i32, i32* %48, i64 %122
store i32 %125, i32* %126
%127 = add nuw nsw i64 %122, 1
%128 = icmp eq i64 %127, %50
br i1 %128, label %89, label %121
129: ; preds = %86, %89
%130 = phi i32* [ %90, %89 ], [ %88, %86 ]
%131 = phi i32* [ %48, %89 ], [ %87, %86 ]
%132 = tail call i32* @malloc(i32 %13)
br label %174
133: ; preds = %165
%134 = tail call i32* @malloc(i32 %13)
br i1 %15, label %135, label %174
135: ; preds = %133
%136 = zext i32 %12 to i64
%137 = icmp ult i32 %12, 9
br i1 %137, label %138, label %140
138: ; preds = %145, %135
%139 = phi i64 [ 0, %135 ], [ %144, %145 ]
br label %186
140: ; preds = %135
%141 = and i64 %19, 7
%142 = icmp eq i64 %141, 0
%143 = select i1 %142, i64 8, i64 %141
%144 = sub nsw i64 %19, %143
br label %145
145: ; preds = %145, %140
%146 = phi i64 [ 0, %140 ], [ %163, %145 ]
%147 = shl nuw nsw i64 %146, 1
%148 = shl i64 %146, 1
%149 = or i64 %147, 1
%150 = or i64 %148, 9
%151 = getelementptr inbounds i32, i32* %1, i64 %149
%152 = getelementptr inbounds i32, i32* %1, i64 %150
%153 = bitcast i32* %151 to <8 x i32>*
%154 = bitcast i32* %152 to <8 x i32>*
%155 = load <8 x i32>, <8 x i32>* %153
%156 = load <8 x i32>, <8 x i32>* %154
%157 = shufflevector <8 x i32> %155, <8 x i32> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%158 = shufflevector <8 x i32> %156, <8 x i32> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%159 = getelementptr inbounds i32, i32* %134, i64 %146
%160 = bitcast i32* %159 to <4 x i32>*
store <4 x i32> %157, <4 x i32>* %160
%161 = getelementptr inbounds i32, i32* %159, i64 4
%162 = bitcast i32* %161 to <4 x i32>*
store <4 x i32> %158, <4 x i32>* %162
%163 = add nuw i64 %146, 8
%164 = icmp eq i64 %163, %144
br i1 %164, label %138, label %145
165: ; preds = %94, %165
%166 = phi i64 [ %172, %165 ], [ %95, %94 ]
%167 = shl nuw nsw i64 %166, 1
%168 = or i64 %167, 1
%169 = getelementptr inbounds i32, i32* %0, i64 %168
%170 = load i32, i32* %169
%171 = getelementptr inbounds i32, i32* %90, i64 %166
store i32 %170, i32* %171
%172 = add nuw nsw i64 %166, 1
%173 = icmp eq i64 %172, %92
br i1 %173, label %133, label %165
174: ; preds = %186, %129, %133
%175 = phi i32* [ %132, %129 ], [ %134, %133 ], [ %134, %186 ]
%176 = phi i32* [ %131, %129 ], [ %48, %133 ], [ %48, %186 ]
%177 = phi i32* [ %130, %129 ], [ %90, %133 ], [ %90, %186 ]
%178 = insertelement <2 x i32> poison, i32 %12, i64 0
%179 = shufflevector <2 x i32> %178, <2 x i32> poison, <2 x i32> zeroinitializer
%180 = insertelement <2 x i32> poison, i32 %12, i64 0
%181 = shufflevector <2 x i32> %180, <2 x i32> poison, <2 x i32> zeroinitializer
%182 = insertelement <2 x i32> poison, i32 %12, i64 0
%183 = shufflevector <2 x i32> %182, <2 x i32> poison, <2 x i32> zeroinitializer
%184 = insertelement <2 x i32> poison, i32 %12, i64 0
%185 = shufflevector <2 x i32> %184, <2 x i32> poison, <2 x i32> zeroinitializer
br label %236
186: ; preds = %138, %186
%187 = phi i64 [ %193, %186 ], [ %139, %138 ]
%188 = shl nuw nsw i64 %187, 1
%189 = or i64 %188, 1
%190 = getelementptr inbounds i32, i32* %1, i64 %189
%191 = load i32, i32* %190
%192 = getelementptr inbounds i32, i32* %134, i64 %187
store i32 %191, i32* %192
%193 = add nuw nsw i64 %187, 1
%194 = icmp eq i64 %193, %136
br i1 %194, label %174, label %186
195: ; preds = %236, %266
br i1 %243, label %196, label %203
196: ; preds = %195
%197 = load i32, i32* %248
%198 = icmp eq i32 %197, -1
br i1 %198, label %297, label %199
199: ; preds = %196
%200 = load i32, i32* %249
%201 = load i32, i32* %250
%202 = icmp slt i32 %200, %201
br i1 %202, label %213, label %207
203: ; preds = %195
%204 = load i32, i32* %246
%205 = load i32, i32* %247
%206 = icmp slt i32 %204, %205
br i1 %206, label %215, label %207
207: ; preds = %203, %199
%208 = phi i32 [ %205, %203 ], [ %201, %199 ]
%209 = phi i32 [ %204, %203 ], [ %200, %199 ]
%210 = load i32, i32* %251
%211 = icmp ne i32 %210, -1
%212 = select i1 %211, i1 true, i1 %243
br i1 %212, label %266, label %215
213: ; preds = %199
%214 = load i32, i32* %252
br label %266
215: ; preds = %203, %207
%216 = phi i32 [ %208, %207 ], [ %205, %203 ]
%217 = phi i32 [ %209, %207 ], [ %204, %203 ]
%218 = zext i32 %237 to i64
%219 = getelementptr inbounds i32, i32* %5, i64 %218
store i32 %217, i32* %219
%220 = icmp sgt i32 %242, %216
br i1 %220, label %221, label %225
221: ; preds = %215
%222 = getelementptr inbounds i32, i32* %175, i64 %245
%223 = load i32, i32* %222
%224 = icmp eq i32 %223, -1
br i1 %224, label %225, label %253
225: ; preds = %221, %215
%226 = or i32 %237, 1
%227 = zext i32 %226 to i64
%228 = getelementptr inbounds i32, i32* %5, i64 %227
store i32 %242, i32* %228
%229 = icmp slt i32 %239, %12
%230 = zext i1 %229 to i32
%231 = add nsw i32 %239, %230
%232 = insertelement <2 x i32> %238, i32 %231, i64 0
br label %233
233: ; preds = %225, %276, %258, %262, %289, %293
%234 = phi <2 x i32> [ %296, %293 ], [ %292, %289 ], [ %265, %262 ], [ %261, %258 ], [ %283, %276 ], [ %232, %225 ]
%235 = add nuw nsw i32 %237, 2
br label %236
236: ; preds = %233, %174
%237 = phi i32 [ 0, %174 ], [ %235, %233 ]
%238 = phi <2 x i32> [ zeroinitializer, %174 ], [ %234, %233 ]
%239 = extractelement <2 x i32> %238, i64 0
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds i32, i32* %177, i64 %240
%242 = load i32, i32* %241
%243 = icmp eq i32 %242, -1
%244 = extractelement <2 x i32> %238, i64 1
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds i32, i32* %14, i64 %240
%247 = getelementptr inbounds i32, i32* %176, i64 %245
%248 = getelementptr inbounds i32, i32* %175, i64 %245
%249 = getelementptr inbounds i32, i32* %14, i64 %240
%250 = getelementptr inbounds i32, i32* %176, i64 %245
%251 = getelementptr inbounds i32, i32* %175, i64 %245
%252 = getelementptr inbounds i32, i32* %175, i64 %245
br label %195
253: ; preds = %221
%254 = icmp sgt i32 %242, %223
%255 = or i32 %237, 1
%256 = zext i32 %255 to i64
%257 = getelementptr inbounds i32, i32* %5, i64 %256
br i1 %254, label %262, label %258
258: ; preds = %253
store i32 %223, i32* %257
%259 = icmp slt <2 x i32> %238, %179
%260 = zext <2 x i1> %259 to <2 x i32>
%261 = add nsw <2 x i32> %238, %260
br label %233
262: ; preds = %253
store i32 %242, i32* %257
%263 = icmp slt <2 x i32> %238, %181
%264 = zext <2 x i1> %263 to <2 x i32>
%265 = add nsw <2 x i32> %238, %264
br label %233
266: ; preds = %213, %207
%267 = phi i32 [ %201, %213 ], [ %208, %207 ]
%268 = phi i32 [ %200, %213 ], [ %209, %207 ]
%269 = phi i32 [ %214, %213 ], [ %210, %207 ]
%270 = icmp eq i32 %269, -1
br i1 %270, label %195, label %271
271: ; preds = %266
%272 = zext i32 %237 to i64
%273 = getelementptr inbounds i32, i32* %5, i64 %272
store i32 %267, i32* %273
%274 = icmp sle i32 %269, %268
%275 = select i1 %274, i1 true, i1 %243
br i1 %275, label %276, label %284
276: ; preds = %271
%277 = or i32 %237, 1
%278 = zext i32 %277 to i64
%279 = getelementptr inbounds i32, i32* %5, i64 %278
store i32 %269, i32* %279
%280 = icmp slt i32 %244, %12
%281 = zext i1 %280 to i32
%282 = add nsw i32 %244, %281
%283 = insertelement <2 x i32> %238, i32 %282, i64 1
br label %233
284: ; preds = %271
%285 = icmp sgt i32 %269, %242
%286 = or i32 %237, 1
%287 = zext i32 %286 to i64
%288 = getelementptr inbounds i32, i32* %5, i64 %287
br i1 %285, label %293, label %289
289: ; preds = %284
store i32 %242, i32* %288
%290 = icmp slt <2 x i32> %238, %183
%291 = zext <2 x i1> %290 to <2 x i32>
%292 = add nsw <2 x i32> %238, %291
br label %233
293: ; preds = %284
store i32 %269, i32* %288
%294 = icmp slt <2 x i32> %238, %185
%295 = zext <2 x i1> %294 to <2 x i32>
%296 = add nsw <2 x i32> %238, %295
br label %233
297: ; preds = %196
%298 = tail call i32 @free(i32* %14)
%299 = tail call i32 @free(i32* %177)
%300 = tail call i32 @free(i32* %176)
%301 = tail call i32 @free(i32* %175)
ret i32* %5
}