#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 */
typedef char uint8_t;
typedef int uint32_t;
typedef int uint16_t;
typedef char router_lifetime;
typedef char retrans_time;
typedef char reachable_time;

/* Variables and functions */
int checksum_icmpv6(char *, int);
int /*<<< orphan*/ memcpy(char *, char *, int);
int /*<<< orphan*/ memset(char *, int /*<<< orphan*/, int);
char *icmp_decompression(char *schc_buffer, char *buffer, int schc_offset,
                         int buffer_offset, int packet_size, uint8_t *mac) {
  uint16_t payload_length = 0;
  uint16_t checksum = 0;
  int icmp = (schc_buffer[0] >> 2) & 7;
  int schc_src = (schc_buffer[0] >> 6) & 1;
  int schc_target = (schc_buffer[0] >> 1) & 1;
  int ix;
  if (icmp == 0) {
    buffer[buffer_offset] = 0x80;
  } else if (icmp == 1) {
    buffer[buffer_offset] = 0x81;
  } else if (icmp == 2) {
    buffer[buffer_offset] = 0x85;
  } else if (icmp == 3) {
    buffer[buffer_offset] = 0x86;
  } else if (icmp == 4) {
    buffer[buffer_offset] = 0x87;
  } else if (icmp == 5) {
    buffer[buffer_offset] = 0x88;
  } else if (icmp == 6) {
    buffer[buffer_offset] = 0x89;
  }
  buffer_offset += 1;
  buffer[buffer_offset] = 0;
  buffer_offset += 1;
  buffer_offset += 2;
  if (icmp == 0 || icmp == 1) {
    memcpy(&buffer[buffer_offset], &schc_buffer[schc_offset], 2);
    buffer_offset += 2;
    schc_offset += 2;
    memcpy(&buffer[buffer_offset], &schc_buffer[schc_offset], 2);
    buffer_offset += 2;
    schc_offset += 2;
    memcpy(&buffer[buffer_offset], &schc_buffer[schc_offset],
           (packet_size - schc_offset));
    buffer_offset += (packet_size - schc_offset);
  } else if (icmp == 2) {
    memcpy(&buffer[16], &schc_buffer[schc_offset], 8);
    buffer[24] = 0xff;
    buffer[25] = 0x02;
    buffer[39] = 0x02;
    buffer[buffer_offset] = 0;
    buffer[buffer_offset + 1] = 0;
    buffer[buffer_offset + 2] = 0;
    buffer[buffer_offset + 3] = 0;
    buffer_offset += 4;
    buffer[buffer_offset] = 1;
    buffer_offset += 1;
    buffer[buffer_offset] = 1;
    buffer_offset += 1;
    for (ix = 0; ix < 6; ix++) {
      buffer[buffer_offset + ix] = mac[ix];
    }
    buffer_offset += 6;
  } else if (icmp == 3) {
    uint16_t router_lifetime = 64800;
    uint32_t reachable_time = 30000;
    uint32_t retrans_time = 1000;
    buffer[buffer_offset] = 0;
    buffer_offset += 1;
    buffer[buffer_offset] = 0;
    buffer_offset += 1;
    buffer[buffer_offset] |= (router_lifetime >> 8) & 255;
    buffer[buffer_offset + 1] |= (router_lifetime)&255;
    buffer_offset += 2;
    buffer[buffer_offset] |= (reachable_time >> 24) & 255;
    buffer[buffer_offset + 1] |= (reachable_time >> 16) & 255;
    buffer[buffer_offset + 2] |= (reachable_time >> 8) & 255;
    buffer[buffer_offset + 3] |= (reachable_time)&255;
    buffer_offset += 4;
    buffer[buffer_offset] |= (retrans_time >> 24) & 255;
    buffer[buffer_offset + 1] |= (retrans_time >> 16) & 255;
    buffer[buffer_offset + 2] |= (retrans_time >> 8) & 255;
    buffer[buffer_offset + 3] |= (retrans_time)&255;
    buffer_offset += 4;
    memcpy(&buffer[buffer_offset], &schc_buffer[schc_offset], 1);
    buffer_offset += 1;
    schc_offset += 1;
    buffer[buffer_offset] = 1;
    buffer_offset += 1;
    memcpy(&buffer[buffer_offset], &schc_buffer[schc_offset], 6);
    buffer_offset += 6;
  } else if (icmp == 4) {
    int i;
    if (schc_src == 0) {
      memcpy(&buffer[16], &schc_buffer[schc_offset], 8);
      schc_offset += 8;
    } else {
      memcpy(&buffer[8], &schc_buffer[schc_offset], 16);
      schc_offset += 16;
    }
    buffer[buffer_offset] = 0;
    buffer[buffer_offset + 1] = 0;
    buffer[buffer_offset + 2] = 0;
    buffer[buffer_offset + 3] = 0;
    buffer_offset += 4;
    if (schc_target == 0) {
      memset(&buffer[buffer_offset], 0, 16);
      buffer[buffer_offset] = 0xfe;
      buffer[buffer_offset + 1] = 0x80;
      buffer_offset += 8;
      for (i = 0; i < 8; i++) {
        buffer[buffer_offset + i] = schc_buffer[schc_offset + i];
      }
      buffer_offset += 8;
    } else {
      memcpy(&buffer[buffer_offset], &schc_buffer[schc_offset], 16);
      buffer_offset += 16;
      schc_offset += 16;
    }
    buffer[buffer_offset] = 1;
    buffer_offset += 1;
    buffer[buffer_offset] = 1;
    buffer_offset += 1;
    for (ix = 0; ix < 6; ix++) {
      buffer[buffer_offset + ix] = mac[ix];
    }
    buffer_offset += 6;
  } else if (icmp == 5) {
    int i;
    buffer[buffer_offset] = 0;
    buffer[buffer_offset] |= 1 << 7;
    buffer[buffer_offset] |= 1 << 6;
    buffer[buffer_offset] |= 0 << 5;
    buffer[buffer_offset + 1] = 0;
    buffer[buffer_offset + 2] = 0;
    buffer[buffer_offset + 3] = 0;
    buffer_offset += 4;
    if (schc_target == 0) {
      memset(&buffer[buffer_offset], 0, 16);
      buffer[buffer_offset] = 0xfe;
      buffer[buffer_offset + 1] = 0x80;
      buffer_offset += 8;
      for (i = 0; i < 8; i++) {
        buffer[buffer_offset + i] = schc_buffer[schc_offset + i];
      }
      buffer_offset += 8;
    } else {
      for (i = 0; i < 16; i++) {
        buffer[buffer_offset + i] = schc_buffer[schc_offset + i];
      }
      buffer_offset += 16;
    }
  } else if (icmp == 6) {
    int i;
    buffer[buffer_offset] = 0;
    buffer[buffer_offset + 1] = 0;
    buffer[buffer_offset + 2] = 0;
    buffer[buffer_offset + 3] = 0;
    buffer_offset += 4;
    memcpy(&buffer[buffer_offset], &schc_buffer[schc_offset], 16);
    buffer_offset += 16;
    schc_offset += 16;
    for (i = 0; i < 16; i++) {
      buffer[buffer_offset + i] = buffer[24 + i];
    }
    buffer_offset += 16;
    memcpy(&buffer[buffer_offset], &schc_buffer[schc_offset], 1);
    buffer_offset += 1;
    schc_offset += 1;
    buffer[buffer_offset] = 1;
    buffer_offset += 1;
    memcpy(&buffer[buffer_offset], &schc_buffer[schc_offset], 6);
    buffer_offset += 6;
  }
  payload_length = (buffer_offset - 40);
  buffer[4] = (payload_length >> 8) & 255;
  buffer[5] = (payload_length >> 0) & 255;
  checksum = checksum_icmpv6(buffer, (buffer_offset));
  buffer[42] = (checksum >> 8) & 255;
  buffer[43] = (checksum >> 0) & 255;
  return buffer;
}


x86 assembly (clang, -O0):
<icmp_decompression>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
sar    $0x2,%eax
and    $0x7,%eax
mov    %eax,-0x34(%rbp)
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
sar    $0x6,%eax
and    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
sar    $0x1,%eax
and    $0x1,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x34(%rbp)
jne    11a7 <icmp_decompression+0x77>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x80,(%rax,%rcx,1)
jmp    1262 <icmp_decompression+0x132>
cmpl   $0x1,-0x34(%rbp)
jne    11c2 <icmp_decompression+0x92>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x81,(%rax,%rcx,1)
jmp    125d <icmp_decompression+0x12d>
cmpl   $0x2,-0x34(%rbp)
jne    11dd <icmp_decompression+0xad>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x85,(%rax,%rcx,1)
jmp    1258 <icmp_decompression+0x128>
cmpl   $0x3,-0x34(%rbp)
jne    11f8 <icmp_decompression+0xc8>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x86,(%rax,%rcx,1)
jmp    1253 <icmp_decompression+0x123>
cmpl   $0x4,-0x34(%rbp)
jne    1213 <icmp_decompression+0xe3>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x87,(%rax,%rcx,1)
jmp    124e <icmp_decompression+0x11e>
cmpl   $0x5,-0x34(%rbp)
jne    122e <icmp_decompression+0xfe>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x88,(%rax,%rcx,1)
jmp    1249 <icmp_decompression+0x119>
cmpl   $0x6,-0x34(%rbp)
jne    1244 <icmp_decompression+0x114>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x89,(%rax,%rcx,1)
jmp    1249 <icmp_decompression+0x119>
jmp    124e <icmp_decompression+0x11e>
jmp    1253 <icmp_decompression+0x123>
jmp    1258 <icmp_decompression+0x128>
jmp    125d <icmp_decompression+0x12d>
jmp    1262 <icmp_decompression+0x132>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x0,-0x34(%rbp)
je     129d <icmp_decompression+0x16d>
cmpl   $0x1,-0x34(%rbp)
jne    1333 <icmp_decompression+0x203>
mov    -0x10(%rbp),%rdi
movslq -0x18(%rbp),%rax
add    %rax,%rdi
mov    -0x8(%rbp),%rsi
movslq -0x14(%rbp),%rax
add    %rax,%rsi
mov    $0x2,%edx
call   1050 <memcpy@plt>
mov    -0x18(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rdi
movslq -0x18(%rbp),%rax
add    %rax,%rdi
mov    -0x8(%rbp),%rsi
movslq -0x14(%rbp),%rax
add    %rax,%rsi
mov    $0x2,%edx
call   1050 <memcpy@plt>
mov    -0x18(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rdi
movslq -0x18(%rbp),%rax
add    %rax,%rdi
mov    -0x8(%rbp),%rsi
movslq -0x14(%rbp),%rax
add    %rax,%rsi
mov    -0x1c(%rbp),%edx
sub    -0x14(%rbp),%edx
call   1050 <memcpy@plt>
mov    -0x1c(%rbp),%eax
sub    -0x14(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
jmp    1ae7 <icmp_decompression+0x9b7>
cmpl   $0x2,-0x34(%rbp)
jne    142c <icmp_decompression+0x2fc>
mov    -0x10(%rbp),%rdi
add    $0x10,%rdi
mov    -0x8(%rbp),%rsi
movslq -0x14(%rbp),%rax
add    %rax,%rsi
mov    $0x8,%edx
call   1050 <memcpy@plt>
mov    -0x10(%rbp),%rax
movb   $0xff,0x18(%rax)
mov    -0x10(%rbp),%rax
movb   $0x2,0x19(%rax)
mov    -0x10(%rbp),%rax
movb   $0x2,0x27(%rax)
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x1,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x1,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
movl   $0x0,-0x40(%rbp)
cmpl   $0x6,-0x40(%rbp)
jge    141e <icmp_decompression+0x2ee>
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    13eb <icmp_decompression+0x2bb>
mov    -0x18(%rbp),%eax
add    $0x6,%eax
mov    %eax,-0x18(%rbp)
jmp    1ae2 <icmp_decompression+0x9b2>
cmpl   $0x3,-0x34(%rbp)
jne    1641 <icmp_decompression+0x511>
movl   $0xfd20,-0x44(%rbp)
movl   $0x7530,-0x48(%rbp)
movl   $0x3e8,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x44(%rbp),%esi
sar    $0x8,%esi
and    $0xff,%esi
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x44(%rbp),%esi
and    $0xff,%esi
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x18(%rbp)
mov    -0x48(%rbp),%esi
sar    $0x18,%esi
and    $0xff,%esi
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x48(%rbp),%esi
sar    $0x10,%esi
and    $0xff,%esi
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x48(%rbp),%esi
sar    $0x8,%esi
and    $0xff,%esi
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x48(%rbp),%esi
and    $0xff,%esi
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x18(%rbp)
mov    -0x4c(%rbp),%esi
sar    $0x18,%esi
and    $0xff,%esi
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x4c(%rbp),%esi
sar    $0x10,%esi
and    $0xff,%esi
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x4c(%rbp),%esi
sar    $0x8,%esi
and    $0xff,%esi
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x4c(%rbp),%esi
and    $0xff,%esi
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rdi
movslq -0x18(%rbp),%rax
add    %rax,%rdi
mov    -0x8(%rbp),%rsi
movslq -0x14(%rbp),%rax
add    %rax,%rsi
mov    $0x1,%edx
call   1050 <memcpy@plt>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x1,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rdi
movslq -0x18(%rbp),%rax
add    %rax,%rdi
mov    -0x8(%rbp),%rsi
movslq -0x14(%rbp),%rax
add    %rax,%rsi
mov    $0x6,%edx
call   1050 <memcpy@plt>
mov    -0x18(%rbp),%eax
add    $0x6,%eax
mov    %eax,-0x18(%rbp)
jmp    1add <icmp_decompression+0x9ad>
cmpl   $0x4,-0x34(%rbp)
jne    1826 <icmp_decompression+0x6f6>
cmpl   $0x0,-0x38(%rbp)
jne    1680 <icmp_decompression+0x550>
mov    -0x10(%rbp),%rdi
add    $0x10,%rdi
mov    -0x8(%rbp),%rsi
movslq -0x14(%rbp),%rax
add    %rax,%rsi
mov    $0x8,%edx
call   1050 <memcpy@plt>
mov    -0x14(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x14(%rbp)
jmp    16a6 <icmp_decompression+0x576>
mov    -0x10(%rbp),%rdi
add    $0x8,%rdi
mov    -0x8(%rbp),%rsi
movslq -0x14(%rbp),%rax
add    %rax,%rsi
mov    $0x10,%edx
call   1050 <memcpy@plt>
mov    -0x14(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jne    1782 <icmp_decompression+0x652>
mov    -0x10(%rbp),%rdi
movslq -0x18(%rbp),%rax
add    %rax,%rdi
xor    %esi,%esi
mov    $0x10,%edx
call   1040 <memset@plt>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0xfe,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x80,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x18(%rbp)
movl   $0x0,-0x50(%rbp)
cmpl   $0x8,-0x50(%rbp)
jge    1774 <icmp_decompression+0x644>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    173c <icmp_decompression+0x60c>
mov    -0x18(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x18(%rbp)
jmp    17b4 <icmp_decompression+0x684>
mov    -0x10(%rbp),%rdi
movslq -0x18(%rbp),%rax
add    %rax,%rdi
mov    -0x8(%rbp),%rsi
movslq -0x14(%rbp),%rax
add    %rax,%rsi
mov    $0x10,%edx
call   1050 <memcpy@plt>
mov    -0x18(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x1,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x1,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
movl   $0x0,-0x40(%rbp)
cmpl   $0x6,-0x40(%rbp)
jge    1818 <icmp_decompression+0x6e8>
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    17e5 <icmp_decompression+0x6b5>
mov    -0x18(%rbp),%eax
add    $0x6,%eax
mov    %eax,-0x18(%rbp)
jmp    1ad8 <icmp_decompression+0x9a8>
cmpl   $0x5,-0x34(%rbp)
jne    1992 <icmp_decompression+0x862>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
or     $0x80,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
or     $0x40,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
or     $0x0,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jne    1945 <icmp_decompression+0x815>
mov    -0x10(%rbp),%rdi
movslq -0x18(%rbp),%rax
add    %rax,%rdi
xor    %esi,%esi
mov    $0x10,%edx
call   1040 <memset@plt>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0xfe,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x80,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x18(%rbp)
movl   $0x0,-0x54(%rbp)
cmpl   $0x8,-0x54(%rbp)
jge    1937 <icmp_decompression+0x807>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    18ff <icmp_decompression+0x7cf>
mov    -0x18(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x18(%rbp)
jmp    198d <icmp_decompression+0x85d>
movl   $0x0,-0x54(%rbp)
cmpl   $0x10,-0x54(%rbp)
jge    1984 <icmp_decompression+0x854>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    194c <icmp_decompression+0x81c>
mov    -0x18(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x18(%rbp)
jmp    1ad3 <icmp_decompression+0x9a3>
cmpl   $0x6,-0x34(%rbp)
jne    1ace <icmp_decompression+0x99e>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rdi
movslq -0x18(%rbp),%rax
add    %rax,%rdi
mov    -0x8(%rbp),%rsi
movslq -0x14(%rbp),%rax
add    %rax,%rsi
mov    $0x10,%edx
call   1050 <memcpy@plt>
mov    -0x18(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x14(%rbp)
movl   $0x0,-0x58(%rbp)
cmpl   $0x10,-0x58(%rbp)
jge    1a55 <icmp_decompression+0x925>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x18,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1a1d <icmp_decompression+0x8ed>
mov    -0x18(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rdi
movslq -0x18(%rbp),%rax
add    %rax,%rdi
mov    -0x8(%rbp),%rsi
movslq -0x14(%rbp),%rax
add    %rax,%rsi
mov    $0x1,%edx
call   1050 <memcpy@plt>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x1,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rdi
movslq -0x18(%rbp),%rax
add    %rax,%rdi
mov    -0x8(%rbp),%rsi
movslq -0x14(%rbp),%rax
add    %rax,%rsi
mov    $0x6,%edx
call   1050 <memcpy@plt>
mov    -0x18(%rbp),%eax
add    $0x6,%eax
mov    %eax,-0x18(%rbp)
jmp    1ad3 <icmp_decompression+0x9a3>
jmp    1ad8 <icmp_decompression+0x9a8>
jmp    1add <icmp_decompression+0x9ad>
jmp    1ae2 <icmp_decompression+0x9b2>
jmp    1ae7 <icmp_decompression+0x9b7>
mov    -0x18(%rbp),%eax
sub    $0x28,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
sar    $0x8,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,0x4(%rax)
mov    -0x2c(%rbp),%eax
sar    $0x0,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,0x5(%rax)
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%esi
call   1030 <checksum_icmpv6@plt>
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
sar    $0x8,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,0x2a(%rax)
mov    -0x30(%rbp),%eax
sar    $0x0,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,0x2b(%rax)
mov    -0x10(%rbp),%rax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<icmp_decompression>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %ecx,%r14d
mov    %rsi,%rbx
movzbl (%rdi),%r13d
mov    %r13d,%ecx
shr    $0x2,%ecx
and    $0x7,%ecx
cmp    $0x6,%ecx
ja     11ed <icmp_decompression+0xbd>
mov    %r8d,%r15d
mov    %edx,%r10d
mov    %rdi,%r8
mov    %r13d,%r12d
shr    %r12d
mov    $0x80,%al
lea    0xe8e(%rip),%rdx
movslq (%rdx,%rcx,4),%rcx
add    %rdx,%rcx
jmp    *%rcx
mov    $0x81,%al
movslq %r14d,%rbp
mov    %al,(%rbx,%rbp,1)
movb   $0x0,0x1(%rbx,%rbp,1)
lea    (%rbx,%rbp,1),%rdi
add    $0x4,%rdi
movslq %r10d,%r12
lea    (%r8,%r12,1),%rsi
mov    $0x2,%edx
mov    %r8,%r13
mov    %r10,0x8(%rsp)
call   1050 <memcpy@plt>
lea    (%rbx,%rbp,1),%rdi
add    $0x6,%rdi
lea    (%r12,%r13,1),%rsi
add    $0x2,%rsi
mov    $0x2,%edx
call   1050 <memcpy@plt>
lea    (%rbx,%rbp,1),%rdi
add    $0x8,%rdi
lea    (%r12,%r13,1),%rsi
add    $0x4,%rsi
sub    0x8(%rsp),%r15d
lea    -0x4(%r15),%edx
call   1050 <memcpy@plt>
add    %r15d,%r14d
add    $0x4,%r14d
jmp    162d <icmp_decompression+0x4fd>
movslq %r14d,%rax
movb   $0x0,0x1(%rax,%rbx,1)
add    $0x4,%r14d
jmp    162d <icmp_decompression+0x4fd>
movslq %r14d,%rbp
movw   $0x85,(%rbx,%rbp,1)
lea    0x10(%rbx),%rdi
movslq %r10d,%rax
add    %rax,%r8
mov    %r8,%rsi
mov    $0x8,%edx
mov    %r9,%r15
call   1050 <memcpy@plt>
movw   $0x2ff,0x18(%rbx)
movb   $0x2,0x27(%rbx)
movl   $0x0,0x4(%rbx,%rbp,1)
movw   $0x101,0x8(%rbx,%rbp,1)
mov    (%r15),%al
mov    %al,0xa(%rbx,%rbp,1)
mov    0x1(%r15),%al
mov    %al,0xb(%rbx,%rbp,1)
mov    0x2(%r15),%al
mov    %al,0xc(%rbx,%rbp,1)
mov    0x3(%r15),%al
mov    %al,0xd(%rbx,%rbp,1)
mov    0x4(%r15),%al
mov    %al,0xe(%rbx,%rbp,1)
mov    0x5(%r15),%al
mov    %al,0xf(%rbx,%rbp,1)
add    $0x10,%r14d
jmp    162d <icmp_decompression+0x4fd>
movslq %r14d,%rbp
movw   $0x86,(%rbx,%rbp,1)
movw   $0x0,0x4(%rbx,%rbp,1)
orb    $0xfd,0x6(%rbx,%rbp,1)
orb    $0x20,0x7(%rbx,%rbp,1)
orb    $0x75,0xa(%rbx,%rbp,1)
orb    $0x30,0xb(%rbx,%rbp,1)
orb    $0x3,0xe(%rbx,%rbp,1)
orb    $0xe8,0xf(%rbx,%rbp,1)
lea    (%rbx,%rbp,1),%rdi
add    $0x10,%rdi
movslq %r10d,%r15
lea    (%r8,%r15,1),%rsi
mov    $0x1,%edx
mov    %r8,%r12
call   1050 <memcpy@plt>
movb   $0x1,0x11(%rbx,%rbp,1)
lea    (%rbx,%rbp,1),%rdi
add    $0x12,%rdi
lea    (%r12,%r15,1),%rsi
add    $0x1,%rsi
mov    $0x6,%edx
call   1050 <memcpy@plt>
jmp    1629 <icmp_decompression+0x4f9>
mov    %r9,0x10(%rsp)
movslq %r14d,%rbp
movw   $0x87,(%rbx,%rbp,1)
xor    %eax,%eax
and    $0x40,%r13d
sete   %al
shr    $0x3,%r13d
lea    0x8(%r13),%edx
lea    (%rbx,%rax,8),%rdi
add    $0x8,%rdi
movslq %r10d,%rsi
add    %r8,%rsi
mov    %r8,%r15
mov    %r10,0x8(%rsp)
call   1050 <memcpy@plt>
mov    0x8(%rsp),%rax
add    %r13d,%eax
add    $0x8,%eax
movl   $0x0,0x4(%rbx,%rbp,1)
lea    (%rbx,%rbp,1),%r13
add    $0x8,%r13
test   $0x1,%r12b
jne    152f <icmp_decompression+0x3ff>
mov    %r13,%rdi
xor    %esi,%esi
mov    $0x10,%edx
mov    %eax,%r12d
call   1040 <memset@plt>
movb   $0xfe,0x0(%r13)
movb   $0x80,0x9(%rbp,%rbx,1)
movslq %r12d,%rax
mov    (%r15,%rax,1),%cl
mov    %cl,0x10(%rbp,%rbx,1)
mov    0x1(%r15,%rax,1),%cl
mov    %cl,0x11(%rbp,%rbx,1)
mov    0x2(%r15,%rax,1),%cl
mov    %cl,0x12(%rbp,%rbx,1)
mov    0x3(%r15,%rax,1),%cl
mov    %cl,0x13(%rbp,%rbx,1)
mov    0x4(%r15,%rax,1),%cl
mov    %cl,0x14(%rbp,%rbx,1)
mov    0x5(%r15,%rax,1),%cl
mov    %cl,0x15(%rbp,%rbx,1)
mov    0x6(%r15,%rax,1),%cl
mov    %cl,0x16(%rbp,%rbx,1)
mov    0x7(%r15,%rax,1),%al
mov    %al,0x17(%rbp,%rbx,1)
jmp    1544 <icmp_decompression+0x414>
movslq %r14d,%rbp
movw   $0x88,(%rbx,%rbp,1)
movl   $0xc0,0x4(%rbx,%rbp,1)
lea    0x8(%rbp),%r13
test   $0x1,%r12b
jne    1582 <icmp_decompression+0x452>
lea    (%rbx,%r13,1),%rdi
xor    %esi,%esi
mov    $0x10,%edx
mov    %r8,%r15
mov    %r10,%r12
call   1040 <memset@plt>
mov    %r15,%r8
movb   $0xfe,(%rbx,%r13,1)
movb   $0x80,0x9(%rbp,%rbx,1)
movslq %r12d,%rax
mov    (%r15,%rax,1),%cl
mov    %cl,0x10(%rbp,%rbx,1)
mov    0x1(%r15,%rax,1),%cl
mov    %cl,0x11(%rbp,%rbx,1)
mov    0x2(%r15,%rax,1),%cl
mov    %cl,0x12(%rbp,%rbx,1)
mov    0x3(%r15,%rax,1),%cl
mov    %cl,0x13(%rbp,%rbx,1)
mov    0x4(%r15,%rax,1),%cl
mov    %cl,0x14(%rbp,%rbx,1)
mov    0x5(%r15,%rax,1),%cl
mov    %cl,0x15(%rbp,%rbx,1)
mov    0x6(%r15,%rax,1),%cl
mov    %cl,0x16(%rbp,%rbx,1)
add    $0x7,%rax
add    $0x17,%rbp
mov    %rbp,%r13
jmp    1621 <icmp_decompression+0x4f1>
movslq %r14d,%r14
movw   $0x89,(%rbx,%r14,1)
movl   $0x0,0x4(%rbx,%r14,1)
lea    (%rbx,%r14,1),%rdi
add    $0x8,%rdi
movslq %r10d,%rbp
lea    (%r8,%rbp,1),%rsi
mov    $0x10,%edx
mov    %r8,%r15
call   1050 <memcpy@plt>
mov    0x18(%rbx),%al
mov    %al,0x18(%rbx,%r14,1)
mov    0x19(%rbx),%al
mov    %al,0x19(%rbx,%r14,1)
mov    0x1a(%rbx),%al
mov    %al,0x1a(%rbx,%r14,1)
mov    0x1b(%rbx),%al
mov    %al,0x1b(%rbx,%r14,1)
mov    0x1c(%rbx),%al
mov    %al,0x1c(%rbx,%r14,1)
mov    0x1d(%rbx),%al
mov    %al,0x1d(%rbx,%r14,1)
mov    0x1e(%rbx),%al
mov    %al,0x1e(%rbx,%r14,1)
mov    0x1f(%rbx),%al
mov    %al,0x1f(%rbx,%r14,1)
mov    0x20(%rbx),%al
mov    %al,0x20(%rbx,%r14,1)
mov    0x21(%rbx),%al
mov    %al,0x21(%rbx,%r14,1)
mov    0x22(%rbx),%al
mov    %al,0x22(%rbx,%r14,1)
mov    0x23(%rbx),%al
mov    %al,0x23(%rbx,%r14,1)
mov    0x24(%rbx),%al
mov    %al,0x24(%rbx,%r14,1)
mov    0x25(%rbx),%al
mov    %al,0x25(%rbx,%r14,1)
mov    0x26(%rbx),%al
mov    %al,0x26(%rbx,%r14,1)
mov    0x27(%rbx),%al
mov    %al,0x27(%rbx,%r14,1)
lea    (%rbx,%r14,1),%rdi
add    $0x28,%rdi
lea    (%r15,%rbp,1),%rsi
add    $0x10,%rsi
mov    $0x1,%edx
call   1050 <memcpy@plt>
movb   $0x1,0x29(%rbx,%r14,1)
lea    (%rbx,%r14,1),%rdi
add    $0x2a,%rdi
lea    (%r15,%rbp,1),%rsi
add    $0x11,%rsi
mov    $0x6,%edx
call   1050 <memcpy@plt>
add    $0x30,%r14d
jmp    162d <icmp_decompression+0x4fd>
cltq
add    %rax,%r15
mov    %r13,%rdi
mov    %r15,%rsi
mov    $0x10,%edx
call   1050 <memcpy@plt>
movw   $0x101,0x18(%rbp,%rbx,1)
mov    0x10(%rsp),%rcx
mov    (%rcx),%al
mov    %al,0x1a(%rbp,%rbx,1)
mov    0x1(%rcx),%al
mov    %al,0x1b(%rbp,%rbx,1)
mov    0x2(%rcx),%al
mov    %al,0x1c(%rbp,%rbx,1)
mov    0x3(%rcx),%al
mov    %al,0x1d(%rbp,%rbx,1)
mov    0x4(%rcx),%al
mov    %al,0x1e(%rbp,%rbx,1)
mov    0x5(%rcx),%al
mov    %al,0x1f(%rbp,%rbx,1)
add    $0x20,%r14d
jmp    162d <icmp_decompression+0x4fd>
movslq %r10d,%rax
mov    (%r8,%rax,1),%cl
mov    %cl,(%rbx,%r13,1)
mov    0x1(%r8,%rax,1),%cl
mov    %cl,0x1(%rbx,%r13,1)
mov    0x2(%r8,%rax,1),%cl
mov    %cl,0x2(%rbx,%r13,1)
mov    0x3(%r8,%rax,1),%cl
mov    %cl,0x3(%rbx,%r13,1)
mov    0x4(%r8,%rax,1),%cl
mov    %cl,0x4(%rbx,%r13,1)
mov    0x5(%r8,%rax,1),%cl
mov    %cl,0x5(%rbx,%r13,1)
mov    0x6(%r8,%rax,1),%cl
mov    %cl,0x6(%rbx,%r13,1)
mov    0x7(%r8,%rax,1),%cl
mov    %cl,0x7(%rbx,%r13,1)
mov    0x8(%r8,%rax,1),%cl
mov    %cl,0x8(%rbx,%r13,1)
mov    0x9(%r8,%rax,1),%cl
mov    %cl,0x9(%rbx,%r13,1)
mov    0xa(%r8,%rax,1),%cl
mov    %cl,0xa(%rbx,%r13,1)
mov    0xb(%r8,%rax,1),%cl
mov    %cl,0xb(%rbx,%r13,1)
mov    0xc(%r8,%rax,1),%cl
mov    %cl,0xc(%rbx,%r13,1)
mov    0xd(%r8,%rax,1),%cl
mov    %cl,0xd(%rbx,%r13,1)
mov    0xe(%r8,%rax,1),%cl
mov    %cl,0xe(%rbx,%r13,1)
add    $0xf,%rax
add    $0xf,%r13
mov    (%r8,%rax,1),%al
mov    %al,(%rbx,%r13,1)
add    $0x18,%r14d
lea    -0x28(%r14),%eax
rol    $0x8,%ax
mov    %ax,0x4(%rbx)
mov    %rbx,%rdi
mov    %r14d,%esi
call   1030 <checksum_icmpv6@plt>
rol    $0x8,%ax
mov    %ax,0x2a(%rbx)
mov    %rbx,%rax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i8* @icmp_decompression(i8* %0, i8* returned %1, i32 %2, i32 %3, i32 %4, i8* nocapture %5) {
%7 = load i8, i8* %0
%8 = zext i8 %7 to i32
%9 = lshr i32 %8, 2
%10 = and i32 %9, 7
%11 = lshr i32 %8, 1
%12 = and i32 %11, 1
switch i32 %10, label %13 [
i32 0, label %19
i32 1, label %18
i32 2, label %48
i32 3, label %104
i32 4, label %163
i32 5, label %276
i32 6, label %426
]
13: ; preds = %6
%14 = add nsw i32 %3, 1
%15 = sext i32 %14 to i64
%16 = getelementptr inbounds i8, i8* %1, i64 %15
store i8 0, i8* %16
%17 = add nsw i32 %3, 4
br label %533
18: ; preds = %6
br label %19
19: ; preds = %6, %18
%20 = phi i8 [ -127, %18 ], [ -128, %6 ]
%21 = sext i32 %3 to i64
%22 = getelementptr inbounds i8, i8* %1, i64 %21
store i8 %20, i8* %22
%23 = add nsw i32 %3, 1
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds i8, i8* %1, i64 %24
store i8 0, i8* %25
%26 = add nsw i32 %3, 4
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds i8, i8* %1, i64 %27
%29 = sext i32 %2 to i64
%30 = getelementptr inbounds i8, i8* %0, i64 %29
%31 = tail call i32 @memcpy(i8* %28, i8* %30, i32 2)
%32 = add nsw i32 %3, 6
%33 = add nsw i32 %2, 2
%34 = sext i32 %32 to i64
%35 = getelementptr inbounds i8, i8* %1, i64 %34
%36 = sext i32 %33 to i64
%37 = getelementptr inbounds i8, i8* %0, i64 %36
%38 = tail call i32 @memcpy(i8* %35, i8* %37, i32 2)
%39 = add nsw i32 %3, 8
%40 = add nsw i32 %2, 4
%41 = sext i32 %39 to i64
%42 = getelementptr inbounds i8, i8* %1, i64 %41
%43 = sext i32 %40 to i64
%44 = getelementptr inbounds i8, i8* %0, i64 %43
%45 = sub nsw i32 %4, %40
%46 = tail call i32 @memcpy(i8* %42, i8* %44, i32 %45)
%47 = add nsw i32 %45, %39
br label %533
48: ; preds = %6
%49 = sext i32 %3 to i64
%50 = getelementptr inbounds i8, i8* %1, i64 %49
store i8 -123, i8* %50
%51 = add nsw i32 %3, 1
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds i8, i8* %1, i64 %52
store i8 0, i8* %53
%54 = add nsw i32 %3, 4
%55 = getelementptr inbounds i8, i8* %1, i64 16
%56 = sext i32 %2 to i64
%57 = getelementptr inbounds i8, i8* %0, i64 %56
%58 = tail call i32 @memcpy(i8* %55, i8* %57, i32 8)
%59 = getelementptr inbounds i8, i8* %1, i64 24
store i8 -1, i8* %59
%60 = getelementptr inbounds i8, i8* %1, i64 25
store i8 2, i8* %60
%61 = getelementptr inbounds i8, i8* %1, i64 39
store i8 2, i8* %61
%62 = sext i32 %54 to i64
%63 = getelementptr inbounds i8, i8* %1, i64 %62
store i8 0, i8* %63
%64 = add nsw i32 %3, 5
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds i8, i8* %1, i64 %65
store i8 0, i8* %66
%67 = add nsw i32 %3, 6
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds i8, i8* %1, i64 %68
store i8 0, i8* %69
%70 = add nsw i32 %3, 7
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds i8, i8* %1, i64 %71
store i8 0, i8* %72
%73 = add nsw i32 %3, 8
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds i8, i8* %1, i64 %74
store i8 1, i8* %75
%76 = add nsw i32 %3, 9
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds i8, i8* %1, i64 %77
store i8 1, i8* %78
%79 = add nsw i32 %3, 10
%80 = sext i32 %79 to i64
%81 = load i8, i8* %5
%82 = getelementptr inbounds i8, i8* %1, i64 %80
store i8 %81, i8* %82
%83 = getelementptr inbounds i8, i8* %5, i64 1
%84 = load i8, i8* %83
%85 = add nsw i64 %80, 1
%86 = getelementptr inbounds i8, i8* %1, i64 %85
store i8 %84, i8* %86
%87 = getelementptr inbounds i8, i8* %5, i64 2
%88 = load i8, i8* %87
%89 = add nsw i64 %80, 2
%90 = getelementptr inbounds i8, i8* %1, i64 %89
store i8 %88, i8* %90
%91 = getelementptr inbounds i8, i8* %5, i64 3
%92 = load i8, i8* %91
%93 = add nsw i64 %80, 3
%94 = getelementptr inbounds i8, i8* %1, i64 %93
store i8 %92, i8* %94
%95 = getelementptr inbounds i8, i8* %5, i64 4
%96 = load i8, i8* %95
%97 = add nsw i64 %80, 4
%98 = getelementptr inbounds i8, i8* %1, i64 %97
store i8 %96, i8* %98
%99 = getelementptr inbounds i8, i8* %5, i64 5
%100 = load i8, i8* %99
%101 = add nsw i64 %80, 5
%102 = getelementptr inbounds i8, i8* %1, i64 %101
store i8 %100, i8* %102
%103 = add nsw i32 %3, 16
br label %533
104: ; preds = %6
%105 = sext i32 %3 to i64
%106 = getelementptr inbounds i8, i8* %1, i64 %105
store i8 -122, i8* %106
%107 = add nsw i32 %3, 1
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds i8, i8* %1, i64 %108
store i8 0, i8* %109
%110 = add nsw i32 %3, 4
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds i8, i8* %1, i64 %111
store i8 0, i8* %112
%113 = add nsw i32 %3, 5
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds i8, i8* %1, i64 %114
store i8 0, i8* %115
%116 = add nsw i32 %3, 6
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds i8, i8* %1, i64 %117
%119 = load i8, i8* %118
%120 = or i8 %119, -3
store i8 %120, i8* %118
%121 = add nsw i32 %3, 7
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds i8, i8* %1, i64 %122
%124 = load i8, i8* %123
%125 = or i8 %124, 32
store i8 %125, i8* %123
%126 = add nsw i32 %3, 10
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds i8, i8* %1, i64 %127
%129 = load i8, i8* %128
%130 = or i8 %129, 117
store i8 %130, i8* %128
%131 = add nsw i32 %3, 11
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds i8, i8* %1, i64 %132
%134 = load i8, i8* %133
%135 = or i8 %134, 48
store i8 %135, i8* %133
%136 = add nsw i32 %3, 14
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds i8, i8* %1, i64 %137
%139 = load i8, i8* %138
%140 = or i8 %139, 3
store i8 %140, i8* %138
%141 = add nsw i32 %3, 15
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds i8, i8* %1, i64 %142
%144 = load i8, i8* %143
%145 = or i8 %144, -24
store i8 %145, i8* %143
%146 = add nsw i32 %3, 16
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds i8, i8* %1, i64 %147
%149 = sext i32 %2 to i64
%150 = getelementptr inbounds i8, i8* %0, i64 %149
%151 = tail call i32 @memcpy(i8* %148, i8* %150, i32 1)
%152 = add nsw i32 %3, 17
%153 = add nsw i32 %2, 1
%154 = sext i32 %152 to i64
%155 = getelementptr inbounds i8, i8* %1, i64 %154
store i8 1, i8* %155
%156 = add nsw i32 %3, 18
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds i8, i8* %1, i64 %157
%159 = sext i32 %153 to i64
%160 = getelementptr inbounds i8, i8* %0, i64 %159
%161 = tail call i32 @memcpy(i8* %158, i8* %160, i32 6)
%162 = add nsw i32 %3, 24
br label %533
163: ; preds = %6
%164 = sext i32 %3 to i64
%165 = getelementptr inbounds i8, i8* %1, i64 %164
store i8 -121, i8* %165
%166 = add nsw i32 %3, 1
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds i8, i8* %1, i64 %167
store i8 0, i8* %168
%169 = add nsw i32 %3, 4
%170 = and i32 %8, 64
%171 = icmp eq i32 %170, 0
%172 = select i1 %171, i64 16, i64 8
%173 = select i1 %171, i32 8, i32 16
%174 = getelementptr inbounds i8, i8* %1, i64 %172
%175 = sext i32 %2 to i64
%176 = getelementptr inbounds i8, i8* %0, i64 %175
%177 = tail call i32 @memcpy(i8* %174, i8* %176, i32 %173)
%178 = add nsw i32 %173, %2
%179 = sext i32 %169 to i64
%180 = getelementptr inbounds i8, i8* %1, i64 %179
store i8 0, i8* %180
%181 = add nsw i32 %3, 5
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds i8, i8* %1, i64 %182
store i8 0, i8* %183
%184 = add nsw i32 %3, 6
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds i8, i8* %1, i64 %185
store i8 0, i8* %186
%187 = add nsw i32 %3, 7
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds i8, i8* %1, i64 %188
store i8 0, i8* %189
%190 = add nsw i32 %3, 8
%191 = icmp eq i32 %12, 0
%192 = sext i32 %190 to i64
%193 = getelementptr inbounds i8, i8* %1, i64 %192
br i1 %191, label %194, label %240
194: ; preds = %163
%195 = tail call i32 @memset(i8* %193, i32 0, i32 16)
store i8 -2, i8* %193
%196 = add nsw i32 %3, 9
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds i8, i8* %1, i64 %197
store i8 -128, i8* %198
%199 = add nsw i32 %3, 16
%200 = sext i32 %178 to i64
%201 = sext i32 %199 to i64
%202 = getelementptr inbounds i8, i8* %0, i64 %200
%203 = load i8, i8* %202
%204 = getelementptr inbounds i8, i8* %1, i64 %201
store i8 %203, i8* %204
%205 = add nsw i64 %200, 1
%206 = getelementptr inbounds i8, i8* %0, i64 %205
%207 = load i8, i8* %206
%208 = add nsw i64 %201, 1
%209 = getelementptr inbounds i8, i8* %1, i64 %208
store i8 %207, i8* %209
%210 = add nsw i64 %200, 2
%211 = getelementptr inbounds i8, i8* %0, i64 %210
%212 = load i8, i8* %211
%213 = add nsw i64 %201, 2
%214 = getelementptr inbounds i8, i8* %1, i64 %213
store i8 %212, i8* %214
%215 = add nsw i64 %200, 3
%216 = getelementptr inbounds i8, i8* %0, i64 %215
%217 = load i8, i8* %216
%218 = add nsw i64 %201, 3
%219 = getelementptr inbounds i8, i8* %1, i64 %218
store i8 %217, i8* %219
%220 = add nsw i64 %200, 4
%221 = getelementptr inbounds i8, i8* %0, i64 %220
%222 = load i8, i8* %221
%223 = add nsw i64 %201, 4
%224 = getelementptr inbounds i8, i8* %1, i64 %223
store i8 %222, i8* %224
%225 = add nsw i64 %200, 5
%226 = getelementptr inbounds i8, i8* %0, i64 %225
%227 = load i8, i8* %226
%228 = add nsw i64 %201, 5
%229 = getelementptr inbounds i8, i8* %1, i64 %228
store i8 %227, i8* %229
%230 = add nsw i64 %200, 6
%231 = getelementptr inbounds i8, i8* %0, i64 %230
%232 = load i8, i8* %231
%233 = add nsw i64 %201, 6
%234 = getelementptr inbounds i8, i8* %1, i64 %233
store i8 %232, i8* %234
%235 = add nsw i64 %200, 7
%236 = getelementptr inbounds i8, i8* %0, i64 %235
%237 = load i8, i8* %236
%238 = add nsw i64 %201, 7
%239 = getelementptr inbounds i8, i8* %1, i64 %238
store i8 %237, i8* %239
br label %244
240: ; preds = %163
%241 = sext i32 %178 to i64
%242 = getelementptr inbounds i8, i8* %0, i64 %241
%243 = tail call i32 @memcpy(i8* %193, i8* %242, i32 16)
br label %244
244: ; preds = %194, %240
%245 = add nsw i32 %3, 24
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds i8, i8* %1, i64 %246
store i8 1, i8* %247
%248 = add nsw i32 %3, 25
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds i8, i8* %1, i64 %249
store i8 1, i8* %250
%251 = add nsw i32 %3, 26
%252 = sext i32 %251 to i64
%253 = load i8, i8* %5
%254 = getelementptr inbounds i8, i8* %1, i64 %252
store i8 %253, i8* %254
%255 = getelementptr inbounds i8, i8* %5, i64 1
%256 = load i8, i8* %255
%257 = add nsw i64 %252, 1
%258 = getelementptr inbounds i8, i8* %1, i64 %257
store i8 %256, i8* %258
%259 = getelementptr inbounds i8, i8* %5, i64 2
%260 = load i8, i8* %259
%261 = add nsw i64 %252, 2
%262 = getelementptr inbounds i8, i8* %1, i64 %261
store i8 %260, i8* %262
%263 = getelementptr inbounds i8, i8* %5, i64 3
%264 = load i8, i8* %263
%265 = add nsw i64 %252, 3
%266 = getelementptr inbounds i8, i8* %1, i64 %265
store i8 %264, i8* %266
%267 = getelementptr inbounds i8, i8* %5, i64 4
%268 = load i8, i8* %267
%269 = add nsw i64 %252, 4
%270 = getelementptr inbounds i8, i8* %1, i64 %269
store i8 %268, i8* %270
%271 = getelementptr inbounds i8, i8* %5, i64 5
%272 = load i8, i8* %271
%273 = add nsw i64 %252, 5
%274 = getelementptr inbounds i8, i8* %1, i64 %273
store i8 %272, i8* %274
%275 = add nsw i32 %3, 32
br label %533
276: ; preds = %6
%277 = sext i32 %3 to i64
%278 = getelementptr inbounds i8, i8* %1, i64 %277
store i8 -120, i8* %278
%279 = add nsw i32 %3, 1
%280 = sext i32 %279 to i64
%281 = getelementptr inbounds i8, i8* %1, i64 %280
store i8 0, i8* %281
%282 = add nsw i32 %3, 4
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds i8, i8* %1, i64 %283
store i8 -64, i8* %284
%285 = add nsw i32 %3, 5
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds i8, i8* %1, i64 %286
store i8 0, i8* %287
%288 = add nsw i32 %3, 6
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds i8, i8* %1, i64 %289
store i8 0, i8* %290
%291 = add nsw i32 %3, 7
%292 = sext i32 %291 to i64
%293 = getelementptr inbounds i8, i8* %1, i64 %292
store i8 0, i8* %293
%294 = add nsw i32 %3, 8
%295 = icmp eq i32 %12, 0
br i1 %295, label %374, label %296
296: ; preds = %276
%297 = sext i32 %2 to i64
%298 = sext i32 %294 to i64
%299 = getelementptr inbounds i8, i8* %0, i64 %297
%300 = load i8, i8* %299
%301 = getelementptr inbounds i8, i8* %1, i64 %298
store i8 %300, i8* %301
%302 = add nsw i64 %297, 1
%303 = getelementptr inbounds i8, i8* %0, i64 %302
%304 = load i8, i8* %303
%305 = add nsw i64 %298, 1
%306 = getelementptr inbounds i8, i8* %1, i64 %305
store i8 %304, i8* %306
%307 = add nsw i64 %297, 2
%308 = getelementptr inbounds i8, i8* %0, i64 %307
%309 = load i8, i8* %308
%310 = add nsw i64 %298, 2
%311 = getelementptr inbounds i8, i8* %1, i64 %310
store i8 %309, i8* %311
%312 = add nsw i64 %297, 3
%313 = getelementptr inbounds i8, i8* %0, i64 %312
%314 = load i8, i8* %313
%315 = add nsw i64 %298, 3
%316 = getelementptr inbounds i8, i8* %1, i64 %315
store i8 %314, i8* %316
%317 = add nsw i64 %297, 4
%318 = getelementptr inbounds i8, i8* %0, i64 %317
%319 = load i8, i8* %318
%320 = add nsw i64 %298, 4
%321 = getelementptr inbounds i8, i8* %1, i64 %320
store i8 %319, i8* %321
%322 = add nsw i64 %297, 5
%323 = getelementptr inbounds i8, i8* %0, i64 %322
%324 = load i8, i8* %323
%325 = add nsw i64 %298, 5
%326 = getelementptr inbounds i8, i8* %1, i64 %325
store i8 %324, i8* %326
%327 = add nsw i64 %297, 6
%328 = getelementptr inbounds i8, i8* %0, i64 %327
%329 = load i8, i8* %328
%330 = add nsw i64 %298, 6
%331 = getelementptr inbounds i8, i8* %1, i64 %330
store i8 %329, i8* %331
%332 = add nsw i64 %297, 7
%333 = getelementptr inbounds i8, i8* %0, i64 %332
%334 = load i8, i8* %333
%335 = add nsw i64 %298, 7
%336 = getelementptr inbounds i8, i8* %1, i64 %335
store i8 %334, i8* %336
%337 = add nsw i64 %297, 8
%338 = getelementptr inbounds i8, i8* %0, i64 %337
%339 = load i8, i8* %338
%340 = add nsw i64 %298, 8
%341 = getelementptr inbounds i8, i8* %1, i64 %340
store i8 %339, i8* %341
%342 = add nsw i64 %297, 9
%343 = getelementptr inbounds i8, i8* %0, i64 %342
%344 = load i8, i8* %343
%345 = add nsw i64 %298, 9
%346 = getelementptr inbounds i8, i8* %1, i64 %345
store i8 %344, i8* %346
%347 = add nsw i64 %297, 10
%348 = getelementptr inbounds i8, i8* %0, i64 %347
%349 = load i8, i8* %348
%350 = add nsw i64 %298, 10
%351 = getelementptr inbounds i8, i8* %1, i64 %350
store i8 %349, i8* %351
%352 = add nsw i64 %297, 11
%353 = getelementptr inbounds i8, i8* %0, i64 %352
%354 = load i8, i8* %353
%355 = add nsw i64 %298, 11
%356 = getelementptr inbounds i8, i8* %1, i64 %355
store i8 %354, i8* %356
%357 = add nsw i64 %297, 12
%358 = getelementptr inbounds i8, i8* %0, i64 %357
%359 = load i8, i8* %358
%360 = add nsw i64 %298, 12
%361 = getelementptr inbounds i8, i8* %1, i64 %360
store i8 %359, i8* %361
%362 = add nsw i64 %297, 13
%363 = getelementptr inbounds i8, i8* %0, i64 %362
%364 = load i8, i8* %363
%365 = add nsw i64 %298, 13
%366 = getelementptr inbounds i8, i8* %1, i64 %365
store i8 %364, i8* %366
%367 = add nsw i64 %297, 14
%368 = getelementptr inbounds i8, i8* %0, i64 %367
%369 = load i8, i8* %368
%370 = add nsw i64 %298, 14
%371 = getelementptr inbounds i8, i8* %1, i64 %370
store i8 %369, i8* %371
%372 = add nsw i64 %297, 15
%373 = add nsw i64 %298, 15
br label %419
374: ; preds = %276
%375 = sext i32 %294 to i64
%376 = getelementptr inbounds i8, i8* %1, i64 %375
%377 = tail call i32 @memset(i8* %376, i32 0, i32 16)
store i8 -2, i8* %376
%378 = add nsw i32 %3, 9
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds i8, i8* %1, i64 %379
store i8 -128, i8* %380
%381 = add nsw i32 %3, 16
%382 = sext i32 %2 to i64
%383 = sext i32 %381 to i64
%384 = getelementptr inbounds i8, i8* %0, i64 %382
%385 = load i8, i8* %384
%386 = getelementptr inbounds i8, i8* %1, i64 %383
store i8 %385, i8* %386
%387 = add nsw i64 %382, 1
%388 = getelementptr inbounds i8, i8* %0, i64 %387
%389 = load i8, i8* %388
%390 = add nsw i64 %383, 1
%391 = getelementptr inbounds i8, i8* %1, i64 %390
store i8 %389, i8* %391
%392 = add nsw i64 %382, 2
%393 = getelementptr inbounds i8, i8* %0, i64 %392
%394 = load i8, i8* %393
%395 = add nsw i64 %383, 2
%396 = getelementptr inbounds i8, i8* %1, i64 %395
store i8 %394, i8* %396
%397 = add nsw i64 %382, 3
%398 = getelementptr inbounds i8, i8* %0, i64 %397
%399 = load i8, i8* %398
%400 = add nsw i64 %383, 3
%401 = getelementptr inbounds i8, i8* %1, i64 %400
store i8 %399, i8* %401
%402 = add nsw i64 %382, 4
%403 = getelementptr inbounds i8, i8* %0, i64 %402
%404 = load i8, i8* %403
%405 = add nsw i64 %383, 4
%406 = getelementptr inbounds i8, i8* %1, i64 %405
store i8 %404, i8* %406
%407 = add nsw i64 %382, 5
%408 = getelementptr inbounds i8, i8* %0, i64 %407
%409 = load i8, i8* %408
%410 = add nsw i64 %383, 5
%411 = getelementptr inbounds i8, i8* %1, i64 %410
store i8 %409, i8* %411
%412 = add nsw i64 %382, 6
%413 = getelementptr inbounds i8, i8* %0, i64 %412
%414 = load i8, i8* %413
%415 = add nsw i64 %383, 6
%416 = getelementptr inbounds i8, i8* %1, i64 %415
store i8 %414, i8* %416
%417 = add nsw i64 %382, 7
%418 = add nsw i64 %383, 7
br label %419
419: ; preds = %296, %374
%420 = phi i64 [ %373, %296 ], [ %418, %374 ]
%421 = phi i64 [ %372, %296 ], [ %417, %374 ]
%422 = getelementptr inbounds i8, i8* %0, i64 %421
%423 = load i8, i8* %422
%424 = getelementptr inbounds i8, i8* %1, i64 %420
store i8 %423, i8* %424
%425 = add nsw i32 %3, 24
br label %533
426: ; preds = %6
%427 = sext i32 %3 to i64
%428 = getelementptr inbounds i8, i8* %1, i64 %427
store i8 -119, i8* %428
%429 = add nsw i32 %3, 1
%430 = sext i32 %429 to i64
%431 = getelementptr inbounds i8, i8* %1, i64 %430
store i8 0, i8* %431
%432 = add nsw i32 %3, 4
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds i8, i8* %1, i64 %433
store i8 0, i8* %434
%435 = add nsw i32 %3, 5
%436 = sext i32 %435 to i64
%437 = getelementptr inbounds i8, i8* %1, i64 %436
store i8 0, i8* %437
%438 = add nsw i32 %3, 6
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds i8, i8* %1, i64 %439
store i8 0, i8* %440
%441 = add nsw i32 %3, 7
%442 = sext i32 %441 to i64
%443 = getelementptr inbounds i8, i8* %1, i64 %442
store i8 0, i8* %443
%444 = add nsw i32 %3, 8
%445 = sext i32 %444 to i64
%446 = getelementptr inbounds i8, i8* %1, i64 %445
%447 = sext i32 %2 to i64
%448 = getelementptr inbounds i8, i8* %0, i64 %447
%449 = tail call i32 @memcpy(i8* %446, i8* %448, i32 16)
%450 = add nsw i32 %3, 24
%451 = sext i32 %450 to i64
%452 = getelementptr inbounds i8, i8* %1, i64 24
%453 = load i8, i8* %452
%454 = getelementptr inbounds i8, i8* %1, i64 %451
store i8 %453, i8* %454
%455 = getelementptr inbounds i8, i8* %1, i64 25
%456 = load i8, i8* %455
%457 = add nsw i64 %451, 1
%458 = getelementptr inbounds i8, i8* %1, i64 %457
store i8 %456, i8* %458
%459 = getelementptr inbounds i8, i8* %1, i64 26
%460 = load i8, i8* %459
%461 = add nsw i64 %451, 2
%462 = getelementptr inbounds i8, i8* %1, i64 %461
store i8 %460, i8* %462
%463 = getelementptr inbounds i8, i8* %1, i64 27
%464 = load i8, i8* %463
%465 = add nsw i64 %451, 3
%466 = getelementptr inbounds i8, i8* %1, i64 %465
store i8 %464, i8* %466
%467 = getelementptr inbounds i8, i8* %1, i64 28
%468 = load i8, i8* %467
%469 = add nsw i64 %451, 4
%470 = getelementptr inbounds i8, i8* %1, i64 %469
store i8 %468, i8* %470
%471 = getelementptr inbounds i8, i8* %1, i64 29
%472 = load i8, i8* %471
%473 = add nsw i64 %451, 5
%474 = getelementptr inbounds i8, i8* %1, i64 %473
store i8 %472, i8* %474
%475 = getelementptr inbounds i8, i8* %1, i64 30
%476 = load i8, i8* %475
%477 = add nsw i64 %451, 6
%478 = getelementptr inbounds i8, i8* %1, i64 %477
store i8 %476, i8* %478
%479 = getelementptr inbounds i8, i8* %1, i64 31
%480 = load i8, i8* %479
%481 = add nsw i64 %451, 7
%482 = getelementptr inbounds i8, i8* %1, i64 %481
store i8 %480, i8* %482
%483 = getelementptr inbounds i8, i8* %1, i64 32
%484 = load i8, i8* %483
%485 = add nsw i64 %451, 8
%486 = getelementptr inbounds i8, i8* %1, i64 %485
store i8 %484, i8* %486
%487 = getelementptr inbounds i8, i8* %1, i64 33
%488 = load i8, i8* %487
%489 = add nsw i64 %451, 9
%490 = getelementptr inbounds i8, i8* %1, i64 %489
store i8 %488, i8* %490
%491 = getelementptr inbounds i8, i8* %1, i64 34
%492 = load i8, i8* %491
%493 = add nsw i64 %451, 10
%494 = getelementptr inbounds i8, i8* %1, i64 %493
store i8 %492, i8* %494
%495 = getelementptr inbounds i8, i8* %1, i64 35
%496 = load i8, i8* %495
%497 = add nsw i64 %451, 11
%498 = getelementptr inbounds i8, i8* %1, i64 %497
store i8 %496, i8* %498
%499 = getelementptr inbounds i8, i8* %1, i64 36
%500 = load i8, i8* %499
%501 = add nsw i64 %451, 12
%502 = getelementptr inbounds i8, i8* %1, i64 %501
store i8 %500, i8* %502
%503 = getelementptr inbounds i8, i8* %1, i64 37
%504 = load i8, i8* %503
%505 = add nsw i64 %451, 13
%506 = getelementptr inbounds i8, i8* %1, i64 %505
store i8 %504, i8* %506
%507 = getelementptr inbounds i8, i8* %1, i64 38
%508 = load i8, i8* %507
%509 = add nsw i64 %451, 14
%510 = getelementptr inbounds i8, i8* %1, i64 %509
store i8 %508, i8* %510
%511 = getelementptr inbounds i8, i8* %1, i64 39
%512 = load i8, i8* %511
%513 = add nsw i64 %451, 15
%514 = getelementptr inbounds i8, i8* %1, i64 %513
store i8 %512, i8* %514
%515 = add nsw i32 %2, 16
%516 = add nsw i32 %3, 40
%517 = sext i32 %516 to i64
%518 = getelementptr inbounds i8, i8* %1, i64 %517
%519 = sext i32 %515 to i64
%520 = getelementptr inbounds i8, i8* %0, i64 %519
%521 = tail call i32 @memcpy(i8* %518, i8* %520, i32 1)
%522 = add nsw i32 %3, 41
%523 = add nsw i32 %2, 17
%524 = sext i32 %522 to i64
%525 = getelementptr inbounds i8, i8* %1, i64 %524
store i8 1, i8* %525
%526 = add nsw i32 %3, 42
%527 = sext i32 %526 to i64
%528 = getelementptr inbounds i8, i8* %1, i64 %527
%529 = sext i32 %523 to i64
%530 = getelementptr inbounds i8, i8* %0, i64 %529
%531 = tail call i32 @memcpy(i8* %528, i8* %530, i32 6)
%532 = add nsw i32 %3, 48
br label %533
533: ; preds = %13, %48, %244, %426, %419, %104, %19
%534 = phi i32 [ %47, %19 ], [ %103, %48 ], [ %162, %104 ], [ %275, %244 ], [ %425, %419 ], [ %532, %426 ], [ %17, %13 ]
%535 = add nsw i32 %534, -40
%536 = lshr i32 %535, 8
%537 = trunc i32 %536 to i8
%538 = getelementptr inbounds i8, i8* %1, i64 4
store i8 %537, i8* %538
%539 = trunc i32 %535 to i8
%540 = getelementptr inbounds i8, i8* %1, i64 5
store i8 %539, i8* %540
%541 = tail call i32 @checksum_icmpv6(i8* %1, i32 %534)
%542 = lshr i32 %541, 8
%543 = trunc i32 %542 to i8
%544 = getelementptr inbounds i8, i8* %1, i64 42
store i8 %543, i8* %544
%545 = trunc i32 %541 to i8
%546 = getelementptr inbounds i8, i8* %1, i64 43
store i8 %545, i8* %546
ret i8* %1
}