#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 int 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 *, int *, int);
char *router_advertisement(char *buffer, uint8_t *IPv6_address,
                           uint8_t *mac_address) {
  int offset = 0;
  uint16_t checksum = 0;
  uint16_t payload_length = 0;
  uint8_t dst_address[16] = {0xff, 0x02, 0, 0, 0, 0, 0, 0,
                             0,    0,    0, 0, 0, 0, 0, 0x01};
  uint16_t router_lifetime = 64800;
  uint32_t reachable_time = 30000;
  uint32_t retrans_time = 1000;
  offset += 8;
  memcpy(&buffer[offset], &IPv6_address[0], 16);
  offset += 16;
  memcpy(&buffer[offset], &dst_address[0], 16);
  offset += 16;
  buffer[offset] = 0x86;
  offset += 1;
  buffer[offset] = 0;
  offset += 1;
  offset += 2;
  buffer[offset] = 0;
  offset += 1;
  buffer[offset] = 0;
  offset += 1;
  buffer[offset] |= (router_lifetime >> 8) & 255;
  buffer[offset + 1] |= (router_lifetime)&255;
  offset += 2;
  buffer[offset] |= (reachable_time >> 24) & 255;
  buffer[offset + 1] |= (reachable_time >> 16) & 255;
  buffer[offset + 2] |= (reachable_time >> 8) & 255;
  buffer[offset + 3] |= (reachable_time)&255;
  offset += 4;
  buffer[offset] |= (retrans_time >> 24) & 255;
  buffer[offset + 1] |= (retrans_time >> 16) & 255;
  buffer[offset + 2] |= (retrans_time >> 8) & 255;
  buffer[offset + 3] |= (retrans_time)&255;
  offset += 4;
  buffer[offset] = 0x01;
  offset += 1;
  buffer[offset] = 0x01;
  offset += 1;
  memcpy(&buffer[offset], &mac_address[0], 6);
  offset += 6;
  payload_length = (offset - 40);
  buffer[4] = (payload_length >> 8) & 255;
  buffer[5] = (payload_length >> 0) & 255;
  checksum = checksum_icmpv6(buffer, (offset));
  buffer[42] = (checksum >> 8) & 255;
  buffer[43] = (checksum >> 0) & 255;
  return buffer;
}


x86 assembly (clang, -O0):
<router_advertisement>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
lea    -0x70(%rbp),%rdi
xor    %esi,%esi
mov    $0x40,%edx
call   1040 <memset@plt>
movl   $0xff,-0x70(%rbp)
movl   $0x2,-0x6c(%rbp)
movl   $0x1,-0x34(%rbp)
movl   $0xfd20,-0x74(%rbp)
movl   $0x7530,-0x78(%rbp)
movl   $0x3e8,-0x7c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rdi
movslq -0x1c(%rbp),%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
mov    $0x10,%edx
call   1050 <memcpy@plt>
mov    -0x1c(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rdi
movslq -0x1c(%rbp),%rax
add    %rax,%rdi
lea    -0x70(%rbp),%rsi
mov    $0x10,%edx
call   1050 <memcpy@plt>
mov    -0x1c(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x86,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x74(%rbp),%esi
sar    $0x8,%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x74(%rbp),%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x78(%rbp),%esi
sar    $0x18,%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x78(%rbp),%esi
sar    $0x10,%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x78(%rbp),%esi
sar    $0x8,%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x78(%rbp),%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x7c(%rbp),%esi
sar    $0x18,%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x7c(%rbp),%esi
sar    $0x10,%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x7c(%rbp),%esi
sar    $0x8,%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x7c(%rbp),%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x1,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x1,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rdi
movslq -0x1c(%rbp),%rax
add    %rax,%rdi
mov    -0x18(%rbp),%rsi
mov    $0x6,%edx
call   1050 <memcpy@plt>
mov    -0x1c(%rbp),%eax
add    $0x6,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x28,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
sar    $0x8,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,0x4(%rax)
mov    -0x24(%rbp),%eax
sar    $0x0,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,0x5(%rax)
mov    -0x8(%rbp),%rdi
mov    -0x1c(%rbp),%esi
call   1030 <checksum_icmpv6@plt>
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
sar    $0x8,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,0x2a(%rax)
mov    -0x20(%rbp),%eax
sar    $0x0,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,0x2b(%rax)
mov    -0x8(%rbp),%rax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<router_advertisement>:
push   %r14
push   %rbx
sub    $0x48,%rsp
mov    %rdx,%r14
mov    %rdi,%rbx
xorps  %xmm0,%xmm0
movaps %xmm0,(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x10(%rsp)
movabs $0x2000000ff,%rax
mov    %rax,(%rsp)
movl   $0x1,0x3c(%rsp)
add    $0x8,%rdi
mov    $0x10,%edx
call   1040 <memcpy@plt>
lea    0x18(%rbx),%rdi
mov    %rsp,%rsi
mov    $0x10,%edx
call   1040 <memcpy@plt>
movw   $0x86,0x28(%rbx)
movw   $0x0,0x2c(%rbx)
orb    $0xfd,0x2e(%rbx)
orb    $0x20,0x2f(%rbx)
orb    $0x75,0x32(%rbx)
orb    $0x30,0x33(%rbx)
orb    $0x3,0x36(%rbx)
orb    $0xe8,0x37(%rbx)
movw   $0x101,0x38(%rbx)
lea    0x3a(%rbx),%rdi
mov    %r14,%rsi
mov    $0x6,%edx
call   1040 <memcpy@plt>
movw   $0x1800,0x4(%rbx)
mov    %rbx,%rdi
mov    $0x40,%esi
call   1030 <checksum_icmpv6@plt>
rol    $0x8,%ax
mov    %ax,0x2a(%rbx)
mov    %rbx,%rax
add    $0x48,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define i8* @router_advertisement(i8* %0, i32* %1, i32* %2) {
%4 = alloca i8*
%5 = alloca i32*
%6 = alloca i32*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca [16 x i32]
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
store i8* %0, i8** %4
store i32* %1, i32** %5
store i32* %2, i32** %6
store i32 0, i32* %7
store i32 0, i32* %8
store i32 0, i32* %9
%14 = bitcast [16 x i32]* %10 to i8*
%15 = bitcast i8* %14 to [16 x i32]*
%16 = getelementptr inbounds [16 x i32], [16 x i32]* %15, i32 0, i32 0
store i32 255, i32* %16
%17 = getelementptr inbounds [16 x i32], [16 x i32]* %15, i32 0, i32 1
store i32 2, i32* %17
%18 = getelementptr inbounds [16 x i32], [16 x i32]* %15, i32 0, i32 15
store i32 1, i32* %18
store i32 64800, i32* %11
store i32 30000, i32* %12
store i32 1000, i32* %13
%19 = load i32, i32* %7
%20 = add nsw i32 %19, 8
store i32 %20, i32* %7
%21 = load i8*, i8** %4
%22 = load i32, i32* %7
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds i8, i8* %21, i64 %23
%25 = load i32*, i32** %5
%26 = getelementptr inbounds i32, i32* %25, i64 0
%27 = call i32 @memcpy(i8* %24, i32* %26, i32 16)
%28 = load i32, i32* %7
%29 = add nsw i32 %28, 16
store i32 %29, i32* %7
%30 = load i8*, i8** %4
%31 = load i32, i32* %7
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds i8, i8* %30, i64 %32
%34 = getelementptr inbounds [16 x i32], [16 x i32]* %10, i64 0, i64 0
%35 = call i32 @memcpy(i8* %33, i32* %34, i32 16)
%36 = load i32, i32* %7
%37 = add nsw i32 %36, 16
store i32 %37, i32* %7
%38 = load i8*, i8** %4
%39 = load i32, i32* %7
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds i8, i8* %38, i64 %40
store i8 -122, i8* %41
%42 = load i32, i32* %7
%43 = add nsw i32 %42, 1
store i32 %43, i32* %7
%44 = load i8*, i8** %4
%45 = load i32, i32* %7
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds i8, i8* %44, i64 %46
store i8 0, i8* %47
%48 = load i32, i32* %7
%49 = add nsw i32 %48, 1
store i32 %49, i32* %7
%50 = load i32, i32* %7
%51 = add nsw i32 %50, 2
store i32 %51, i32* %7
%52 = load i8*, i8** %4
%53 = load i32, i32* %7
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds i8, i8* %52, i64 %54
store i8 0, i8* %55
%56 = load i32, i32* %7
%57 = add nsw i32 %56, 1
store i32 %57, i32* %7
%58 = load i8*, i8** %4
%59 = load i32, i32* %7
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds i8, i8* %58, i64 %60
store i8 0, i8* %61
%62 = load i32, i32* %7
%63 = add nsw i32 %62, 1
store i32 %63, i32* %7
%64 = load i32, i32* %11
%65 = ashr i32 %64, 8
%66 = and i32 %65, 255
%67 = load i8*, i8** %4
%68 = load i32, i32* %7
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds i8, i8* %67, i64 %69
%71 = load i8, i8* %70
%72 = sext i8 %71 to i32
%73 = or i32 %72, %66
%74 = trunc i32 %73 to i8
store i8 %74, i8* %70
%75 = load i32, i32* %11
%76 = and i32 %75, 255
%77 = load i8*, i8** %4
%78 = load i32, i32* %7
%79 = add nsw i32 %78, 1
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds i8, i8* %77, i64 %80
%82 = load i8, i8* %81
%83 = sext i8 %82 to i32
%84 = or i32 %83, %76
%85 = trunc i32 %84 to i8
store i8 %85, i8* %81
%86 = load i32, i32* %7
%87 = add nsw i32 %86, 2
store i32 %87, i32* %7
%88 = load i32, i32* %12
%89 = ashr i32 %88, 24
%90 = and i32 %89, 255
%91 = load i8*, i8** %4
%92 = load i32, i32* %7
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds i8, i8* %91, i64 %93
%95 = load i8, i8* %94
%96 = sext i8 %95 to i32
%97 = or i32 %96, %90
%98 = trunc i32 %97 to i8
store i8 %98, i8* %94
%99 = load i32, i32* %12
%100 = ashr i32 %99, 16
%101 = and i32 %100, 255
%102 = load i8*, i8** %4
%103 = load i32, i32* %7
%104 = add nsw i32 %103, 1
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds i8, i8* %102, i64 %105
%107 = load i8, i8* %106
%108 = sext i8 %107 to i32
%109 = or i32 %108, %101
%110 = trunc i32 %109 to i8
store i8 %110, i8* %106
%111 = load i32, i32* %12
%112 = ashr i32 %111, 8
%113 = and i32 %112, 255
%114 = load i8*, i8** %4
%115 = load i32, i32* %7
%116 = add nsw i32 %115, 2
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds i8, i8* %114, i64 %117
%119 = load i8, i8* %118
%120 = sext i8 %119 to i32
%121 = or i32 %120, %113
%122 = trunc i32 %121 to i8
store i8 %122, i8* %118
%123 = load i32, i32* %12
%124 = and i32 %123, 255
%125 = load i8*, i8** %4
%126 = load i32, i32* %7
%127 = add nsw i32 %126, 3
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds i8, i8* %125, i64 %128
%130 = load i8, i8* %129
%131 = sext i8 %130 to i32
%132 = or i32 %131, %124
%133 = trunc i32 %132 to i8
store i8 %133, i8* %129
%134 = load i32, i32* %7
%135 = add nsw i32 %134, 4
store i32 %135, i32* %7
%136 = load i32, i32* %13
%137 = ashr i32 %136, 24
%138 = and i32 %137, 255
%139 = load i8*, i8** %4
%140 = load i32, i32* %7
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds i8, i8* %139, i64 %141
%143 = load i8, i8* %142
%144 = sext i8 %143 to i32
%145 = or i32 %144, %138
%146 = trunc i32 %145 to i8
store i8 %146, i8* %142
%147 = load i32, i32* %13
%148 = ashr i32 %147, 16
%149 = and i32 %148, 255
%150 = load i8*, i8** %4
%151 = load i32, i32* %7
%152 = add nsw i32 %151, 1
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds i8, i8* %150, i64 %153
%155 = load i8, i8* %154
%156 = sext i8 %155 to i32
%157 = or i32 %156, %149
%158 = trunc i32 %157 to i8
store i8 %158, i8* %154
%159 = load i32, i32* %13
%160 = ashr i32 %159, 8
%161 = and i32 %160, 255
%162 = load i8*, i8** %4
%163 = load i32, i32* %7
%164 = add nsw i32 %163, 2
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds i8, i8* %162, i64 %165
%167 = load i8, i8* %166
%168 = sext i8 %167 to i32
%169 = or i32 %168, %161
%170 = trunc i32 %169 to i8
store i8 %170, i8* %166
%171 = load i32, i32* %13
%172 = and i32 %171, 255
%173 = load i8*, i8** %4
%174 = load i32, i32* %7
%175 = add nsw i32 %174, 3
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds i8, i8* %173, i64 %176
%178 = load i8, i8* %177
%179 = sext i8 %178 to i32
%180 = or i32 %179, %172
%181 = trunc i32 %180 to i8
store i8 %181, i8* %177
%182 = load i32, i32* %7
%183 = add nsw i32 %182, 4
store i32 %183, i32* %7
%184 = load i8*, i8** %4
%185 = load i32, i32* %7
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds i8, i8* %184, i64 %186
store i8 1, i8* %187
%188 = load i32, i32* %7
%189 = add nsw i32 %188, 1
store i32 %189, i32* %7
%190 = load i8*, i8** %4
%191 = load i32, i32* %7
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds i8, i8* %190, i64 %192
store i8 1, i8* %193
%194 = load i32, i32* %7
%195 = add nsw i32 %194, 1
store i32 %195, i32* %7
%196 = load i8*, i8** %4
%197 = load i32, i32* %7
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds i8, i8* %196, i64 %198
%200 = load i32*, i32** %6
%201 = getelementptr inbounds i32, i32* %200, i64 0
%202 = call i32 @memcpy(i8* %199, i32* %201, i32 6)
%203 = load i32, i32* %7
%204 = add nsw i32 %203, 6
store i32 %204, i32* %7
%205 = load i32, i32* %7
%206 = sub nsw i32 %205, 40
store i32 %206, i32* %9
%207 = load i32, i32* %9
%208 = ashr i32 %207, 8
%209 = and i32 %208, 255
%210 = trunc i32 %209 to i8
%211 = load i8*, i8** %4
%212 = getelementptr inbounds i8, i8* %211, i64 4
store i8 %210, i8* %212
%213 = load i32, i32* %9
%214 = ashr i32 %213, 0
%215 = and i32 %214, 255
%216 = trunc i32 %215 to i8
%217 = load i8*, i8** %4
%218 = getelementptr inbounds i8, i8* %217, i64 5
store i8 %216, i8* %218
%219 = load i8*, i8** %4
%220 = load i32, i32* %7
%221 = call i32 @checksum_icmpv6(i8* %219, i32 %220)
store i32 %221, i32* %8
%222 = load i32, i32* %8
%223 = ashr i32 %222, 8
%224 = and i32 %223, 255
%225 = trunc i32 %224 to i8
%226 = load i8*, i8** %4
%227 = getelementptr inbounds i8, i8* %226, i64 42
store i8 %225, i8* %227
%228 = load i32, i32* %8
%229 = ashr i32 %228, 0
%230 = and i32 %229, 255
%231 = trunc i32 %230 to i8
%232 = load i8*, i8** %4
%233 = getelementptr inbounds i8, i8* %232, i64 43
store i8 %231, i8* %233
%234 = load i8*, i8** %4
ret i8* %234
}

LLVM IR (-O2):
define i8* @router_advertisement(i8* returned %0, i32* %1, i32* %2) {
%4 = alloca [16 x i32]
%5 = bitcast [16 x i32]* %4 to i8*
%6 = getelementptr inbounds [16 x i32], [16 x i32]* %4, i64 0, i64 0
store i32 255, i32* %6
%7 = getelementptr inbounds [16 x i32], [16 x i32]* %4, i64 0, i64 1
store i32 2, i32* %7
%8 = getelementptr inbounds [16 x i32], [16 x i32]* %4, i64 0, i64 15
store i32 1, i32* %8
%9 = getelementptr inbounds i8, i8* %0, i64 8
%10 = tail call i32 @memcpy(i8* %9, i32* %1, i32 16)
%11 = getelementptr inbounds i8, i8* %0, i64 24
%12 = call i32 @memcpy(i8* %11, i32* %6, i32 16)
%13 = getelementptr inbounds i8, i8* %0, i64 40
store i8 -122, i8* %13
%14 = getelementptr inbounds i8, i8* %0, i64 41
store i8 0, i8* %14
%15 = getelementptr inbounds i8, i8* %0, i64 44
store i8 0, i8* %15
%16 = getelementptr inbounds i8, i8* %0, i64 45
store i8 0, i8* %16
%17 = getelementptr inbounds i8, i8* %0, i64 46
%18 = load i8, i8* %17
%19 = or i8 %18, -3
store i8 %19, i8* %17
%20 = getelementptr inbounds i8, i8* %0, i64 47
%21 = load i8, i8* %20
%22 = or i8 %21, 32
store i8 %22, i8* %20
%23 = getelementptr inbounds i8, i8* %0, i64 50
%24 = load i8, i8* %23
%25 = or i8 %24, 117
store i8 %25, i8* %23
%26 = getelementptr inbounds i8, i8* %0, i64 51
%27 = load i8, i8* %26
%28 = or i8 %27, 48
store i8 %28, i8* %26
%29 = getelementptr inbounds i8, i8* %0, i64 54
%30 = load i8, i8* %29
%31 = or i8 %30, 3
store i8 %31, i8* %29
%32 = getelementptr inbounds i8, i8* %0, i64 55
%33 = load i8, i8* %32
%34 = or i8 %33, -24
store i8 %34, i8* %32
%35 = getelementptr inbounds i8, i8* %0, i64 56
store i8 1, i8* %35
%36 = getelementptr inbounds i8, i8* %0, i64 57
store i8 1, i8* %36
%37 = getelementptr inbounds i8, i8* %0, i64 58
%38 = call i32 @memcpy(i8* %37, i32* %2, i32 6)
%39 = getelementptr inbounds i8, i8* %0, i64 4
store i8 0, i8* %39
%40 = getelementptr inbounds i8, i8* %0, i64 5
store i8 24, i8* %40
%41 = call i32 @checksum_icmpv6(i8* %0, i32 64)
%42 = lshr i32 %41, 8
%43 = trunc i32 %42 to i8
%44 = getelementptr inbounds i8, i8* %0, i64 42
store i8 %43, i8* %44
%45 = trunc i32 %41 to i8
%46 = getelementptr inbounds i8, i8* %0, i64 43
store i8 %45, i8* %46
ret i8* %0
}