LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack7x24c28
static inline bool unpack7x24c28(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x, y, out;
    V32x4 mask = VDUP32(Mask(7));
    if (!unpack6(s, &x)) return false;
    x = glue12(x);
    VSTORE(v + 0, VAND(x, mask));
    x = glue24(x);
    VSTORE(v + 4, VAND(VSHR32(x, 7), mask));
    VSTORE(v + 8, VAND(VSHR32(x, 14), mask));
    if (!unpack6(s + 12, &y)) return false;
    y = VSHUF8(y, V8x16_C(
	     4,  5,  6, -1,  7,  8,  9, -1,
	    10, 11, 12, -1, 13, 14, 15, -1));
    out = VOR(VSHR32(x, 21), VSHL32(y, 3));
    y = glue12(y);
    VSTORE(v + 12, VAND(out, mask));
    VSTORE(v + 16, VAND(VSHR32(y, 4), mask));
    y = glue24(y);
    VSTORE(v + 20, VSHR32(y, 11));
    return (void) e, true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30(%rsp), %rsi
callq 0x6bf8
testb %al, %al
je 0x14d1
vmovdqa 0x30(%rsp), %xmm0
vpmaddubsw 0x6b32(%rip), %xmm0, %xmm0 # 0x7f50
vpbroadcastq 0x70f1(%rip), %xmm2 # 0x8518
vpand %xmm2, %xmm0, %xmm1
vpmaddwd 0x6b2d(%rip), %xmm0, %xmm3 # 0x7f60
vmovdqu %xmm1, (%rbx)
vpsrld $0x7, %xmm3, %xmm0
vpand %xmm2, %xmm0, %xmm0
vmovdqu %xmm0, 0x10(%rbx)
vmovdqa %xmm3, (%rsp)
vpsrld $0xe, %xmm3, %xmm0
vmovdqa %xmm2, 0x10(%rsp)
vpand %xmm2, %xmm0, %xmm0
vmovdqu %xmm0, 0x20(%rbx)
addq $0xc, %r14
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x6bf8
testb %al, %al
je 0x14d1
vmovdqa 0x20(%rsp), %xmm0
vpshufb 0x6bbe(%rip), %xmm0, %xmm0 # 0x8040
vmovdqa (%rsp), %xmm1
vpsrld $0x15, %xmm1, %xmm1
vpslld $0x3, %xmm0, %xmm2
vpor %xmm1, %xmm2, %xmm1
vpmaddubsw 0x6ab2(%rip), %xmm0, %xmm0 # 0x7f50
vmovdqa 0x10(%rsp), %xmm2
vpand %xmm2, %xmm1, %xmm1
vmovdqu %xmm1, 0x30(%rbx)
vpsrld $0x4, %xmm0, %xmm1
vpand %xmm2, %xmm1, %xmm1
vpmaddwd 0x6aa2(%rip), %xmm0, %xmm0 # 0x7f60
vmovdqu %xmm1, 0x40(%rbx)
vpsrld $0xb, %xmm0, %xmm0
vmovdqu %xmm0, 0x50(%rbx)
movb $0x1, %al
jmp 0x14d3
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack8x12c16
static inline bool unpack8x12c16(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x;
    if (!unpack6(s, &x)) return false;
    x = glue12(x);
    VSTORE(v + 0, VAND(x, VDUP32(Mask(8))));
    x = glue24(x);
    VSTORE(v + 4, VSHUF8(x, V8x16_C(
	    1, -1, -1, -1,  5, -1, -1, -1,
	    9, -1, -1, -1, 13, -1, -1, -1)));
    VSTORE(v + 8, VSHR32(x, 16));
    return (void) e, true;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rsp, %rsi
callq 0x6bf8
testb %al, %al
je 0x1546
vmovdqa (%rsp), %xmm0
vpmaddubsw 0x6a36(%rip), %xmm0, %xmm0 # 0x7f50
vpand 0x6b2e(%rip), %xmm0, %xmm1 # 0x8050
vpmaddwd 0x6a36(%rip), %xmm0, %xmm0 # 0x7f60
vpshufb 0x6aad(%rip), %xmm0, %xmm2 # 0x7fe0
vmovdqu %xmm1, (%rbx)
vmovdqu %xmm2, 0x10(%rbx)
vpsrld $0x10, %xmm0, %xmm0
vmovdqu %xmm0, 0x20(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack9x32c48
static inline bool unpack9x32c48(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x0, x1, x2, out;
    V32x4 mask = VDUP32(Mask(9));
    if (!unpack6(s, &x0)) return false;
    x0 = glue12(x0);
    VSTORE(v + 0, VAND(x0, mask));
    x0 = glue24(x0);
    VSTORE(v + 4, VAND(VSHR32(x0, 9), mask));
    if (!unpack6(s + 16, &x1)) return false;
    out = VOR(VSHR32(x0, 18), VSHL32(x1, 6));
    x1 = glue12(x1);
    VSTORE(v + 8, VAND(out, mask));
    VSTORE(v + 12, VAND(VSHR32(x1, 3), mask));
    x1 = glue24(x1);
    VSTORE(v + 16, VAND(VSHR32(x1, 12), mask));
    if (!unpack6(s + 32, &x2)) return false;
    out = VOR(VSHR32(x1, 21), VSHL32(x2, 3));
    x2 = glue12(x2);
    VSTORE(v + 20, VAND(out, mask));
    x2 = glue24(x2);
    VSTORE(v + 24, VAND(VSHR32(x2, 6), mask));
    VSTORE(v + 28, VSHR32(x2, 15));
    return (void) e, true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x40(%rsp), %rsi
callq 0x6bf8
testb %al, %al
je 0x173d
vmovdqa 0x40(%rsp), %xmm0
vpmaddubsw 0x691f(%rip), %xmm0, %xmm0 # 0x7f50
vpbroadcastq 0x6ee6(%rip), %xmm2 # 0x8520
vpand %xmm2, %xmm0, %xmm1
vmovdqu %xmm1, (%rbx)
vpmaddwd 0x6916(%rip), %xmm0, %xmm0 # 0x7f60
vmovdqa %xmm0, (%rsp)
vpsrld $0x9, %xmm0, %xmm0
vmovdqa %xmm2, 0x10(%rsp)
vpand %xmm2, %xmm0, %xmm0
vmovdqu %xmm0, 0x10(%rbx)
leaq 0x10(%r14), %rdi
leaq 0x30(%rsp), %rsi
callq 0x6bf8
testb %al, %al
je 0x173d
vmovdqa (%rsp), %xmm0
vpsrld $0x12, %xmm0, %xmm0
vmovdqa 0x30(%rsp), %xmm1
vpslld $0x6, %xmm1, %xmm2
vpmaddubsw 0x68b9(%rip), %xmm1, %xmm1 # 0x7f50
vpor %xmm0, %xmm2, %xmm0
vmovdqa 0x10(%rsp), %xmm2
vpand %xmm2, %xmm0, %xmm0
vmovdqu %xmm0, 0x20(%rbx)
vpsrld $0x3, %xmm1, %xmm0
vpand %xmm2, %xmm0, %xmm0
vmovdqu %xmm0, 0x30(%rbx)
vpmaddwd 0x68a0(%rip), %xmm1, %xmm0 # 0x7f60
vmovdqa %xmm0, (%rsp)
vpsrld $0xc, %xmm0, %xmm0
vpand %xmm2, %xmm0, %xmm0
vmovdqu %xmm0, 0x40(%rbx)
addq $0x20, %r14
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x6bf8
testb %al, %al
je 0x173d
vmovdqa (%rsp), %xmm0
vpsrld $0x15, %xmm0, %xmm0
vmovdqa 0x20(%rsp), %xmm1
vpslld $0x3, %xmm1, %xmm2
vpor %xmm0, %xmm2, %xmm0
vpmaddubsw 0x6846(%rip), %xmm1, %xmm1 # 0x7f50
vmovdqa 0x10(%rsp), %xmm2
vpand %xmm2, %xmm0, %xmm0
vmovdqu %xmm0, 0x50(%rbx)
vpmaddwd 0x683f(%rip), %xmm1, %xmm0 # 0x7f60
vpsrld $0x6, %xmm0, %xmm1
vpand %xmm2, %xmm1, %xmm1
vmovdqu %xmm1, 0x60(%rbx)
vpsrld $0xf, %xmm0, %xmm0
vmovdqu %xmm0, 0x70(%rbx)
movb $0x1, %al
jmp 0x173f
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack10x9c15
static inline bool unpack10x9c15(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x;
    if (!unpack6(s - 1, &x)) return false;
    x = glue12(x);
    v[8] = VEXTR16(x, 7) >> 2;
    x = glue24(x);
    x = VSHUF8(x, V8x16_C(
	    0, 1,  6,  8, 2, 4,  9, 10,
	    4, 5, 10, 12, 5, 6, 12, 13));
    x = VSHLV16(x, 0, 0, 6, 6, 4, 4, 2, 2);
    x = VSHR16(x, 6);
    VSTORE(v, VAND(x, VDUP32(0xffff)));
    VSTORE(v + 4, VSHR32(x, 16));
    return (void) e, true;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
decq %rdi
movq %rsp, %rsi
callq 0x6bf8
testb %al, %al
je 0x187d
vmovdqa (%rsp), %xmm0
vpmaddubsw 0x6725(%rip), %xmm0, %xmm0 # 0x7f50
vpextrw $0x7, %xmm0, %ecx
shrl $0x2, %ecx
movl %ecx, 0x20(%rbx)
vpmaddwd 0x6722(%rip), %xmm0, %xmm0 # 0x7f60
vpshufb 0x6899(%rip), %xmm0, %xmm0 # 0x80e0
vpmulhuw 0x68a1(%rip), %xmm0, %xmm1 # 0x80f0
vpbroadcastw 0x6d00(%rip), %xmm2 # 0x8558
vpblendd $0x2, %xmm0, %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[1],xmm1[2,3]
vpand %xmm2, %xmm0, %xmm1
vpbroadcastq 0x6cbd(%rip), %xmm2 # 0x8528
vpand %xmm2, %xmm0, %xmm0
vmovdqu %xmm0, (%rbx)
vpsrld $0x10, %xmm1, %xmm0
vmovdqu %xmm0, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack10x24c40
static inline bool unpack10x24c40(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x0, x1, x2, out;
    V32x4 mask = VDUP32(Mask(10));
    if (!unpack6(s +  0, &x0)) return false;
    x0 = glue12(x0);
    VSTORE(v, VAND(x0, mask));
    x0 = glue24(x0);
    VSTORE(v + 4, VAND(VSHR32(x0, 10), mask));
    if (!unpack6(s + 16, &x1)) return false;
    out = VOR(VSHR32(x0, 20), VSHL32(x1, 4));
    x1 = glue12(x1);
    VSTORE(v + 8, VAND(out, mask));
    x1 = glue24(x1);
    VSTORE(v + 12, VAND(VSHR32(x1, 6), mask));
    if (!unpack6(s + 24, &x2)) return false;
    x2 = VSHUF8(x2, V8x16_C(
	     8,  9, -1, -1, 10, 11, -1, -1,
	    12, 13, -1, -1, 14, 15, -1, -1));
    out = VOR(VSHR32(x1, 16), VSHL32(x2, 8));
    x2 = glue12(x2);
    VSTORE(v + 16, VAND(out, mask));
    VSTORE(v + 20, VSHR32(x2, 2));
    return (void) e, true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x40(%rsp), %rsi
callq 0x6bf8
testb %al, %al
je 0x1bd5
vmovdqa 0x40(%rsp), %xmm0
vpmaddubsw 0x6467(%rip), %xmm0, %xmm0 # 0x7f50
vpbroadcastq 0x6a36(%rip), %xmm2 # 0x8528
vpand %xmm2, %xmm0, %xmm1
vmovdqu %xmm1, (%rbx)
vpmaddwd 0x645e(%rip), %xmm0, %xmm0 # 0x7f60
vmovdqa %xmm0, (%rsp)
vpsrld $0xa, %xmm0, %xmm0
vmovdqa %xmm2, 0x10(%rsp)
vpand %xmm2, %xmm0, %xmm0
vmovdqu %xmm0, 0x10(%rbx)
leaq 0x10(%r14), %rdi
leaq 0x30(%rsp), %rsi
callq 0x6bf8
testb %al, %al
je 0x1bd5
vmovdqa (%rsp), %xmm0
vpsrld $0x14, %xmm0, %xmm0
vmovdqa 0x30(%rsp), %xmm1
vpslld $0x4, %xmm1, %xmm2
vpor %xmm0, %xmm2, %xmm0
vpmaddubsw 0x63fd(%rip), %xmm1, %xmm1 # 0x7f50
vmovdqa 0x10(%rsp), %xmm2
vpand %xmm2, %xmm0, %xmm0
vmovdqu %xmm0, 0x20(%rbx)
vpmaddwd 0x63f6(%rip), %xmm1, %xmm0 # 0x7f60
vmovdqa %xmm0, (%rsp)
vpsrld $0x6, %xmm0, %xmm0
vpand %xmm2, %xmm0, %xmm0
vmovdqu %xmm0, 0x30(%rbx)
addq $0x18, %r14
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x6bf8
testb %al, %al
je 0x1bd5
vmovdqa 0x20(%rsp), %xmm0
vpxor %xmm1, %xmm1, %xmm1
vpunpckhwd %xmm1, %xmm0, %xmm0 # xmm0 = xmm0[4],xmm1[4],xmm0[5],xmm1[5],xmm0[6],xmm1[6],xmm0[7],xmm1[7]
vmovdqa (%rsp), %xmm1
vpsrld $0x10, %xmm1, %xmm1
vpslld $0x8, %xmm0, %xmm2
vpor %xmm1, %xmm2, %xmm1
vpmaddubsw 0x6394(%rip), %xmm0, %xmm0 # 0x7f50
vpand 0x10(%rsp), %xmm1, %xmm1
vmovdqu %xmm1, 0x40(%rbx)
vpsrld $0x2, %xmm0, %xmm0
vmovdqu %xmm0, 0x50(%rbx)
movb $0x1, %al
jmp 0x1bd7
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack11x8c15e2
static inline bool unpack11x8c15e2(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x, y;
    if (!unpack6(s - 1, &x)) return false;
    *e = VEXTR32(x, 0) >> 28;
    x = glue24(glue12(x));
    y = VSHUF8(x, V8x16_C(
	    -1,  0, 1, 4, -1, -1, 4, 5,
	    -1, -1, 5, 6, -1,  6, 8, 9));
    y = VSHLV32(y, 7, 4, 1, 6);
    y = VSHR32(y, 21);
    VSTORE(v, y);
    y = VSHUF8(x, V8x16_C(
	    -1, -1,  9, 10, -1, -1, 10, 12,
	    -1, -1, 13, 14, -1, -1, 14,  2));
    y = VSHLV32(y, 3, 0, 5, 2);
    y = VSHR32(y, 21);
    VSTORE(v + 4, y);
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
decq %rdi
movq %rsp, %rsi
callq 0x6bf8
testb %al, %al
je 0x1c75
movl (%rsp), %ecx
shrl $0x1c, %ecx
vmovdqa (%rsp), %xmm0
movl %ecx, (%r14)
vpmaddubsw 0x6321(%rip), %xmm0, %xmm0 # 0x7f50
vpmaddwd 0x6329(%rip), %xmm0, %xmm0 # 0x7f60
vpshufb 0x6540(%rip), %xmm0, %xmm1 # 0x8180
vpsrlvd 0x6547(%rip), %xmm1, %xmm1 # 0x8190
vpbroadcastd 0x6896(%rip), %xmm2 # 0x84e8
vpand %xmm2, %xmm1, %xmm1
vmovdqu %xmm1, (%rbx)
vpshufb 0x653d(%rip), %xmm0, %xmm0 # 0x81a0
vpsrlvd 0x6544(%rip), %xmm0, %xmm0 # 0x81b0
vpand %xmm2, %xmm0, %xmm0
vmovdqu %xmm0, 0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack11x8c16e8
static inline bool unpack11x8c16e8(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x, y;
    if (!unpack6(s, &x)) return false;
    x = glue12(x);
    *e = VEXTR8(x, 0);
    x = glue24(x);
    y = VSHUF8(x, V8x16_C(
	    -1, -1, 1, 2, -1, -1, 2, 4,
	    -1,  4, 5, 6, -1,  5, 6, 8));
    y = VSHLV32(y, 5, 2, 7, 4);
    y = VSHR32(y, 21);
    VSTORE(v, y);
    y = VSHUF8(x, V8x16_C(
	    -1, -1,  8,  9, -1,  9, 10, 12,
	    -1, -1, 12, 13, -1, -1, 13, 14));
    y = VSHLV32(y, 1, 6, 3, 0);
    y = VSHR32(y, 21);
    VSTORE(v + 4, y);
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rsp, %rsi
callq 0x6bf8
testb %al, %al
je 0x1d10
vmovdqa (%rsp), %xmm0
vpmaddubsw 0x628f(%rip), %xmm0, %xmm0 # 0x7f50
vpextrb $0x0, %xmm0, %ecx
movl %ecx, (%r14)
vpmaddwd 0x628e(%rip), %xmm0, %xmm0 # 0x7f60
vpshufb 0x64e5(%rip), %xmm0, %xmm1 # 0x81c0
vpsrlvd 0x64ec(%rip), %xmm1, %xmm1 # 0x81d0
vpbroadcastd 0x67fb(%rip), %xmm2 # 0x84e8
vpand %xmm2, %xmm1, %xmm1
vmovdqu %xmm1, (%rbx)
vpshufb 0x64e2(%rip), %xmm0, %xmm0 # 0x81e0
vpsrlvd 0x64e9(%rip), %xmm0, %xmm0 # 0x81f0
vpand %xmm2, %xmm0, %xmm0
vmovdqu %xmm0, 0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack11x9c18e9
static inline bool unpack11x9c18e9(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x, y;
    if (!unpack6(s + 2, &x)) return false;
    x = glue12(x);
    uint32_t b = base64dec2(s);
    if ((int32_t) b < 0) return false;
    uint32_t c = VEXTR8(x, 0);
    x = glue24(x);
    *e = b & Mask(9);
    v[0] = (b | c << 12) >> 9;
    y = VSHUF8(x, V8x16_C(
	    -1, 0, 1, 2, -1, -1, 2, 4,
	    -1, 4, 5, 6, -1,  5, 6, 8));
    y = VSHLV32(y, 5, 2, 7, 4);
    y = VSHR32(y, 21);
    VSTORE(v + 1, y);
    y = VSHUF8(x, V8x16_C(
	    -1, -1,  8,  9, -1,  9, 10, 12,
	    -1, -1, 12, 13, -1, -1, 13, 14));
    y = VSHLV32(y, 1, 6, 3, 0);
    y = VSHR32(y, 21);
    VSTORE(v + 5, y);
    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
addq $0x2, %rdi
movq %rsp, %rsi
callq 0x6bf8
testb %al, %al
je 0x1ded
movzbl (%r15), %eax
movzbl 0x1(%r15), %ecx
leaq 0x52e5(%rip), %rdx      # 0x7050
movsbl (%rax,%rdx), %eax
orw 0x100(%rdx,%rcx,2), %ax
js 0x1ded
movzwl %ax, %eax
vmovdqa (%rsp), %xmm0
vpmaddubsw 0x61c6(%rip), %xmm0, %xmm0 # 0x7f50
vpextrb $0x0, %xmm0, %ecx
vpmaddwd 0x61c8(%rip), %xmm0, %xmm0 # 0x7f60
shll $0xc, %ecx
orl %eax, %ecx
andl $0x1ff, %eax            # imm = 0x1FF
movl %eax, (%r14)
shrl $0x9, %ecx
vpshufb 0x644f(%rip), %xmm0, %xmm1 # 0x8200
vpsrlvd 0x6416(%rip), %xmm1, %xmm1 # 0x81d0
movl %ecx, (%rbx)
vpbroadcastd 0x6723(%rip), %xmm2 # 0x84e8
vpand %xmm2, %xmm1, %xmm1
vpshufb 0x640e(%rip), %xmm0, %xmm0 # 0x81e0
vpsrlvd 0x6415(%rip), %xmm0, %xmm0 # 0x81f0
vmovdqu %xmm1, 0x4(%rbx)
vpand %xmm2, %xmm0, %xmm0
vmovdqu %xmm0, 0x14(%rbx)
movb $0x1, %al
jmp 0x1def
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack12x8c16
static inline bool unpack12x8c16(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x;
    if (!unpack6(s, &x)) return false;
    x = glue12(x);
    VSTORE(v + 0, VMOVZWLO(x));
    VSTORE(v + 4, VMOVZWHI(x));
    return (void) e, true;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rsp, %rsi
callq 0x6bf8
testb %al, %al
je 0x1e4e
vmovdqa (%rsp), %xmm0
vpmaddubsw 0x6118(%rip), %xmm0, %xmm0 # 0x7f50
vpmovzxwd %xmm0, %xmm1    # xmm1 = xmm0[0],zero,xmm0[1],zero,xmm0[2],zero,xmm0[3],zero
vmovdqu %xmm1, (%rbx)
vpxor %xmm1, %xmm1, %xmm1
vpunpckhwd %xmm1, %xmm0, %xmm0 # xmm0 = xmm0[4],xmm1[4],xmm0[5],xmm1[5],xmm0[6],xmm1[6],xmm0[7],xmm1[7]
vmovdqu %xmm0, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack12x16c32
static inline bool unpack12x16c32(const char *s, uint32_t *v, unsigned *e)
{
#ifdef W32x8
    W32x8 x, lo, hi;
    x = Wunpack6x(WLOAD(s), &lo, &hi);
    x = Wglue12(x);
    if (Wu6err(lo, hi)) return false;
    WSTORE(v + 0, WMOVZWLO(x));
    WSTORE(v + 8, WMOVZWHI(x));
    return (void) e, true;
#else
    V32x4 x, y;
    if (!unpack6(s +  0, &x)) return false;
    x = glue12(x);
    if (!unpack6(s + 16, &y)) return false;
    y = glue12(y);
    VSTORE(v +  0, VMOVZWLO(x));
    VSTORE(v +  4, VMOVZWHI(x));
    VSTORE(v +  8, VMOVZWLO(y));
    VSTORE(v + 12, VMOVZWHI(y));
    return (void) e, true;
#endif
}

// Assembly:
vmovdqu (%rdi), %ymm0
vpsrld $0x4, %ymm0, %ymm1
vpand 0x66fe(%rip), %ymm1, %ymm1 # 0x8580
vpbroadcastb 0x66d3(%rip), %ymm2 # 0x855e
vpand %ymm2, %ymm0, %ymm3
vbroadcasti128 0x6288(%rip), %ymm4 # ymm4 = mem[0,1,0,1]
vpshufb %ymm3, %ymm4, %ymm3
vbroadcasti128 0x628a(%rip), %ymm4 # ymm4 = mem[0,1,0,1]
vpshufb %ymm1, %ymm4, %ymm4
vptest %ymm4, %ymm3
sete %al
jne 0x1ef1
vpcmpeqb %ymm2, %ymm0, %ymm2
vpaddb %ymm2, %ymm1, %ymm1
vbroadcasti128 0x624a(%rip), %ymm2 # ymm2 = mem[0,1,0,1]
vpshufb %ymm1, %ymm2, %ymm1
vpaddb %ymm0, %ymm1, %ymm0
vpmaddubsw 0x6728(%rip), %ymm0, %ymm0 # 0x8600
vpmovzxwd %xmm0, %ymm1    # ymm1 = xmm0[0],zero,xmm0[1],zero,xmm0[2],zero,xmm0[3],zero,xmm0[4],zero,xmm0[5],zero,xmm0[6],zero,xmm0[7],zero
vmovdqu %ymm1, (%rsi)
vextracti128 $0x1, %ymm0, %xmm0
vpmovzxwd %xmm0, %ymm0    # ymm0 = xmm0[0],zero,xmm0[1],zero,xmm0[2],zero,xmm0[3],zero,xmm0[4],zero,xmm0[5],zero,xmm0[6],zero,xmm0[7],zero
vmovdqu %ymm0, 0x20(%rsi)
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack13x7c16e5
static inline bool unpack13x7c16e5(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x, y;
    if (!unpack6(s, &x)) return false;
    *e = VEXTR32(x, 0) & Mask(5);
    x = glue24(glue12(x));
    y = VSHUF8(x, V8x16_C(
	    -1, 0, 1, 2, -1, -1, 2, 4,
	    -1, 4, 5, 6, -1,  6, 8, 9));
    y = VSHLV32(y, 6, 1, 4, 7);
    y = VSHR32(y, 19);
    VSTORE(v, y);
    y = VSHUF8(x, V8x16_C(
	    -1, -1,  9, 10, -1, 10, 12, 13,
	    -1, -1, 13, 14, -1, -1, -1, -1));
    y = VSHLV32(y, 2, 5, 0, 0);
    y = VSHR32(y, 19);
    VSTORE(v + 4, y);
    return (void) e, true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rsp, %rsi
callq 0x6bf8
testb %al, %al
je 0x1f88
movl (%rsp), %ecx
andl $0x1f, %ecx
vmovdqa (%rsp), %xmm0
movl %ecx, (%r14)
vpmaddubsw 0x600e(%rip), %xmm0, %xmm0 # 0x7f50
vpmaddwd 0x6016(%rip), %xmm0, %xmm0 # 0x7f60
vpshufb 0x62bd(%rip), %xmm0, %xmm1 # 0x8210
vpsrlvd 0x62c4(%rip), %xmm1, %xmm1 # 0x8220
vpbroadcastd 0x6587(%rip), %xmm2 # 0x84ec
vpand %xmm2, %xmm1, %xmm1
vmovdqu %xmm1, (%rbx)
vpshufb 0x62ba(%rip), %xmm0, %xmm0 # 0x8230
vpsrlvd 0x62c1(%rip), %xmm0, %xmm0 # 0x8240
vpand %xmm2, %xmm0, %xmm0
vmovdqu %xmm0, 0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack14x6c14
static inline bool unpack14x6c14(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x, y;
    if (!unpack24(s - 2, &x)) return false;
    y = VSHUF8(x, V8x16_C(
	    -1,  1, 2, 4, -1, -1, 4,  5,
	    -1, -1, 6, 8, -1,  8, 9, 10));
    y = VSHLV32(y, 6, 0, 2, 4);
    y = VSHR32(y, 18);
    VSTORE(v, y);
    y = VSHUF8(x, V8x16_C(
	    -1, 10, 12, 13, -1, -1, 13, 14,
	    -1, -1, -1, -1, -1, -1, -1, -1));
#if VSHLV32_COST >= 2
    x = VSHL32(y, 6);
    y = VBLEND16(y, x, 0x33);
#else
    y = VSHLV32(y, 6, 0, 0, 0);
#endif
    y = VSHR32(y, 18);
    VSTORE64(v + 4, y);
    return (void) e, true;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
addq $-0x2, %rdi
movq %rsp, %rsi
callq 0x6c56
testb %al, %al
je 0x208a
vmovdqa (%rsp), %xmm0
vpshufb 0x623e(%rip), %xmm0, %xmm1 # 0x8290
vpsrlvd 0x6245(%rip), %xmm1, %xmm1 # 0x82a0
vpbroadcastd 0x648c(%rip), %xmm2 # 0x84f0
vpand %xmm2, %xmm1, %xmm1
vmovdqu %xmm1, (%rbx)
vpshufb 0x623b(%rip), %xmm0, %xmm0 # 0x82b0
vpslld $0x6, %xmm0, %xmm1
vpblendd $0x2, %xmm0, %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[1],xmm1[2,3]
vpsrld $0x12, %xmm0, %xmm0
vmovq %xmm0, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack15x6c15
static inline bool unpack15x6c15(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x, y;
    if (!unpack24(s - 1, &x)) return false;
    y = VSHUF8(x, V8x16_C(
	    -1, 0, 1, 2, -1, 2, 4, 5,
	    -1, 5, 6, 8, -1, 8, 9, 10));
    y = VSHLV32(y, 3, 4, 5, 6);
    y = VSHR32(y, 17);
    VSTORE(v, y);
    y = VSHUF8(x, V8x16_C(
	    -1, 10, 12, 13, -1, -1, 13, 14,
	    -1, -1, -1, -1, -1, -1, -1, -1));
#if VSHLV32_COST >= 2
    x = VSHL32(y, 7);
    y = VBLEND16(y, x, 0x33);
#else
    y = VSHLV32(y, 7, 0, 0, 0);
#endif
    y = VSHR32(y, 17);
    VSTORE64(v + 4, y);
    return (void) e, true;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
decq %rdi
movq %rsp, %rsi
callq 0x6c56
testb %al, %al
je 0x210a
vmovdqa (%rsp), %xmm0
vpshufb 0x61ee(%rip), %xmm0, %xmm1 # 0x82c0
vpsrlvd 0x61f5(%rip), %xmm1, %xmm1 # 0x82d0
vpbroadcastd 0x6410(%rip), %xmm2 # 0x84f4
vpand %xmm2, %xmm1, %xmm1
vmovdqu %xmm1, (%rbx)
vpshufb 0x61bb(%rip), %xmm0, %xmm0 # 0x82b0
vpslld $0x7, %xmm0, %xmm1
vpblendd $0x2, %xmm0, %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[1],xmm1[2,3]
vpsrld $0x11, %xmm0, %xmm0
vmovq %xmm0, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack16x6c16
static inline bool unpack16x6c16(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x, y;
    if (!unpack24(s, &x)) return false;
    y = VSHUF8(x, V8x16_C(
	    0, 1, -1, -1, 2, 4, -1, -1,
	    5, 6, -1, -1, 8, 9, -1, -1));
    VSTORE(v, y);
    y = VSHUF8(x, V8x16_C(
	    10, 12, -1, -1, 13, 14, -1, -1,
	    -1, -1, -1, -1, -1, -1, -1, -1));
    VSTORE64(v + 4, y);
    return (void) e, true;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rsp, %rsi
callq 0x6c56
testb %al, %al
je 0x2161
vmovdqa (%rsp), %xmm0
vpshufb 0x6191(%rip), %xmm0, %xmm1 # 0x82e0
vmovdqu %xmm1, (%rbx)
vpshufb 0x6194(%rip), %xmm0, %xmm0 # 0x82f0
vmovq %xmm0, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack17x5c15e5
static inline bool unpack17x5c15e5(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x;
    if (!unpack6(s - 1, &x)) return false;
    *e = VEXTR32(x, 0) >> 25;
    x = glue24(glue12(x));
    v[0] = VEXTR32(x, 1) >> 7;
    x = VSHUF8(x, V8x16_C(
	    -1,  0,  1,  4, -1,  8,  9, 10,
	    -1, 10, 12, 13, -1, 13, 14,  2));
    x = VSHLV32(x, 1, 7, 6, 5);
    x = VSHR32(x, 15);
    VSTORE(v + 1, x);
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
decq %rdi
movq %rsp, %rsi
callq 0x6bf8
testb %al, %al
je 0x21ee
movl (%rsp), %ecx
shrl $0x19, %ecx
vmovdqa (%rsp), %xmm0
movl %ecx, (%r14)
vpmaddubsw 0x5d99(%rip), %xmm0, %xmm0 # 0x7f50
vpmaddwd 0x5da1(%rip), %xmm0, %xmm0 # 0x7f60
vpextrd $0x1, %xmm0, %ecx
shrl $0x7, %ecx
movl %ecx, (%rbx)
vpshufb 0x612d(%rip), %xmm0, %xmm0 # 0x8300
vpsrlvd 0x6134(%rip), %xmm0, %xmm0 # 0x8310
vpbroadcastd 0x6313(%rip), %xmm1 # 0x84f8
vpand %xmm1, %xmm0, %xmm0
vmovdqu %xmm0, 0x4(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack17x6c17
static inline bool unpack17x6c17(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x, y;
    if (!unpack24(s, &x)) return false;
    y = VSHUF8(x, V8x16_C(
	    -1, 0, 1, 2, -1, 2, 4,  5,
	    -1, 5, 6, 8, -1, 8, 9, 10));
    y = VSHLV32(y, 7, 6, 5, 4);
    y = VSHR32(y, 15);
    VSTORE(v, y);
    y = VSHUF8(x, V8x16_C(
	    -1, 10, 12, 13, -1, 13, 14, -1,
	    -1, -1, -1, -1, -1, -1, -1, -1));
    y = VSHLV32(y, 3, 2, 0, 0);
    y = VSHR32(y, 15);
    VSTORE64(v + 4, y);
    int32_t z = base64dec1(s + 16);
    if (z < 0) return false;
    v[5] |= (z << 11);
    return (void) e, true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %rsi
callq 0x6c56
testb %al, %al
je 0x2299
vmovdqa (%rsp), %xmm0
vpshufb 0x6086(%rip), %xmm0, %xmm1 # 0x82c0
vpsrlvd 0x60dd(%rip), %xmm1, %xmm1 # 0x8320
vpbroadcastd 0x62ac(%rip), %xmm2 # 0x84f8
vpand %xmm2, %xmm1, %xmm1
vmovdqu %xmm1, (%rbx)
vpshufb 0x60d3(%rip), %xmm0, %xmm0 # 0x8330
vpsllvd 0x60da(%rip), %xmm0, %xmm0 # 0x8340
vpsrld $0xf, %xmm0, %xmm0
vmovq %xmm0, 0x10(%rbx)
movzbl 0x10(%r14), %eax
leaq 0x4dd4(%rip), %rcx      # 0x7050
movsbl (%rax,%rcx), %eax
testl %eax, %eax
js 0x2299
vmovq %xmm0, %rcx
shrq $0x20, %rcx
shll $0xb, %eax
orl %ecx, %eax
movl %eax, 0x14(%rbx)
movb $0x1, %al
jmp 0x229b
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack18x5c15
static inline bool unpack18x5c15(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x;
    if (!unpack24(s - 1, &x)) return false;
    v[0] = VEXTR32(x, 0) >> 6;
    const V32x4 shuf = V8x16_C(
	    -1, 4,  5,  6, -1,  6,  8,  9,
	    -1, 9, 10, 12, -1, 12, 13, 14);
    x = VSHUF8(x, shuf);
    x = VSHLV32(x, 6, 4, 2, 0);
    x = VSHR32(x, 14);
    VSTORE(v + 1, x);
    return (void) e, true;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
decq %rdi
movq %rsp, %rsi
callq 0x6c56
testb %al, %al
je 0x2308
movl (%rsp), %ecx
shrl $0x6, %ecx
vmovdqa (%rsp), %xmm0
movl %ecx, (%rbx)
vpshufb 0x6063(%rip), %xmm0, %xmm0 # 0x8350
vpsrlvd 0x606a(%rip), %xmm0, %xmm0 # 0x8360
vpbroadcastd 0x61fd(%rip), %xmm1 # 0x84fc
vpand %xmm1, %xmm0, %xmm0
vmovdqu %xmm0, 0x4(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack19x4c13e2o1
static inline bool unpack19x4c13e2o1(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x;
    if (!unpack6(s - 2, &x)) return false;
    *e = VEXTR16(x, 1) & Mask(2);
    x = glue24(glue12(x));
    x = VSHUF8(x, V8x16_C(
	     1, 2, 4,  5, -1,  5,  6,  8,
	    -1, 8, 9, 10, 10, 12, 13, 14));
    x = VSHLV32(x, 7, 4, 1, 6);
    VSTORE(v, VSHR32(x, 13));
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
addq $-0x2, %rdi
movq %rsp, %rsi
callq 0x6bf8
testb %al, %al
je 0x238c
vmovdqa (%rsp), %xmm0
vpextrw $0x1, %xmm0, %ecx
andl $0x3, %ecx
movl %ecx, (%r14)
vpmaddubsw 0x5bef(%rip), %xmm0, %xmm0 # 0x7f50
vpmaddwd 0x5bf7(%rip), %xmm0, %xmm0 # 0x7f60
vpshufb 0x5ffe(%rip), %xmm0, %xmm0 # 0x8370
vpsrlvd 0x6005(%rip), %xmm0, %xmm0 # 0x8380
vpbroadcastd 0x617c(%rip), %xmm1 # 0x8500
vpand %xmm1, %xmm0, %xmm0
vmovdqu %xmm0, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack19x5c16e1
static inline bool unpack19x5c16e1(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x;
    if (!unpack6(s, &x)) return false;
    *e = VEXTR32(x, 0) & 1;
    x = glue24(glue12(x));
    v[0] = (VEXTR32(x, 0) >> 1) & Mask(19);
    x = VSHUF8(x, V8x16_C(
	    -1, 2,  4,  5,  5,  6,  8,  9,
	    -1, 9, 10, 12, -1, 12, 13, 14));
    x = VSHLV32(x, 1, 6, 3, 0);
    VSTORE(v + 1, VSHR32(x, 13));
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rsp, %rsi
callq 0x6bf8
testb %al, %al
je 0x241b
movl (%rsp), %ecx
andl $0x1, %ecx
vmovdqa (%rsp), %xmm0
movl %ecx, (%r14)
vpmaddubsw 0x5b6f(%rip), %xmm0, %xmm0 # 0x7f50
vpmaddwd 0x5b77(%rip), %xmm0, %xmm0 # 0x7f60
vmovd %xmm0, %ecx
shrl %ecx
andl $0x7ffff, %ecx          # imm = 0x7FFFF
movl %ecx, (%rbx)
vpshufb 0x5f90(%rip), %xmm0, %xmm0 # 0x8390
vpsrlvd 0x5f97(%rip), %xmm0, %xmm0 # 0x83a0
vpbroadcastd 0x60ee(%rip), %xmm1 # 0x8500
vpand %xmm1, %xmm0, %xmm0
vmovdqu %xmm0, 0x4(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack20x4c14e4
static inline bool unpack20x4c14e4(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x;
    if (!unpack6(s - 2, &x)) return false;
    *e = VEXTR16(x, 1) & Mask(4);
    x = glue24(glue12(x));
    x = VSHUF8(x, V8x16_C(
	    -1, 2,  4,  5, -1,  5,  6,  8,
	    -1, 9, 10, 12, -1, 12, 13, 14));
#if VSHLV32_COST >= 2
    x = VBLEND16(x, VSHL32(x, 4), 0x33);
#else
    x = VSHLV32(x, 4, 0, 4, 0);
#endif
    VSTORE(v, VSHR32(x, 12));
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
addq $-0x2, %rdi
movq %rsp, %rsi
callq 0x6bf8
testb %al, %al
je 0x249b
vmovdqa (%rsp), %xmm0
vpextrw $0x1, %xmm0, %ecx
andl $0xf, %ecx
movl %ecx, (%r14)
vpmaddubsw 0x5ada(%rip), %xmm0, %xmm0 # 0x7f50
vpmaddwd 0x5ae2(%rip), %xmm0, %xmm0 # 0x7f60
vpshufb 0x5f29(%rip), %xmm0, %xmm0 # 0x83b0
vpslld $0x4, %xmm0, %xmm1
vpblendd $0xa, %xmm0, %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[1],xmm1[2],xmm0[3]
vpsrld $0xc, %xmm0, %xmm0
vmovdqu %xmm0, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack20x6c20
static inline bool unpack20x6c20(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x;
    if (!unpack24(s, &x)) return false;
    uint32_t d = VEXTR32(x, 3);
    x = VSHUF8(x, V8x16_C(
	    -1, 0, 1, 2, -1, 2,  4,  5,
	    -1, 6, 8, 9, -1, 9, 10, 12));
#if VSHLV32_COST >= 2
    x = VBLEND16(x, VSHL32(x, 4), 0x33);
#else
    x = VSHLV32(x, 4, 0, 4, 0);
#endif
    VSTORE(v, VSHR32(x, 12));
    int32_t b = base64dec4(s + 16);
    if (b < 0) return false;
    v[4] = (d >> 8) | (b & Mask(4)) << 16;
    v[5] = (b >> 4);
    return (void) e, true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %rsi
callq 0x6c56
testb %al, %al
je 0x2556
vmovdqa (%rsp), %xmm0
vpshufb 0x5ed9(%rip), %xmm0, %xmm1 # 0x83c0
vpslld $0x4, %xmm1, %xmm2
vpblendd $0xa, %xmm1, %xmm2, %xmm1 # xmm1 = xmm2[0],xmm1[1],xmm2[2],xmm1[3]
vpsrld $0xc, %xmm1, %xmm1
vmovdqu %xmm1, (%rbx)
movzbl 0x10(%r14), %eax
movzbl 0x11(%r14), %ecx
movzbl 0x12(%r14), %edx
movzbl 0x13(%r14), %esi
leaq 0x4b3a(%rip), %rdi      # 0x7050
movsbl (%rax,%rdi), %r8d
movswl 0x100(%rdi,%rcx,2), %eax
orl %r8d, %eax
orl 0x300(%rdi,%rdx,4), %eax
orl 0x700(%rdi,%rsi,4), %eax
js 0x2556
vpextrd $0x3, %xmm0, %ecx
shrl $0x8, %ecx
movl %eax, %edx
andl $0xf, %edx
shll $0x10, %edx
orl %ecx, %edx
movl %edx, 0x10(%rbx)
shrl $0x4, %eax
movl %eax, 0x14(%rbx)
movb $0x1, %al
jmp 0x2558
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack22x4c15e2
static inline bool unpack22x4c15e2(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x;
    if (!unpack6(s - 1, &x)) return false;
    *e = VEXTR32(x, 0) >> 28;
    x = glue24(glue12(x));
    x = VSHUF8(x, V8x16_C(
	    0,  1,  4,  5,  5,  6, 8,  9,
	    9, 10, 12, -1, 13, 14, 2, -1));
    x = VSHLV32(x, 4, 6, 8, 10);
    VSTORE(v, VSHR32(x, 10));
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
decq %rdi
movq %rsp, %rsi
callq 0x6bf8
testb %al, %al
je 0x264f
movl (%rsp), %ecx
shrl $0x1c, %ecx
vmovdqa (%rsp), %xmm0
movl %ecx, (%r14)
vpmaddubsw 0x592c(%rip), %xmm0, %xmm0 # 0x7f50
vpmaddwd 0x5934(%rip), %xmm0, %xmm0 # 0x7f60
vpshufb 0x5d9b(%rip), %xmm0, %xmm0 # 0x83d0
vpsrlvd 0x5da2(%rip), %xmm0, %xmm0 # 0x83e0
vpbroadcastd 0x5ebd(%rip), %xmm1 # 0x8504
vpand %xmm1, %xmm0, %xmm0
vmovdqu %xmm0, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack23x4c16e4
static inline bool unpack23x4c16e4(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x, y;
    if (!unpack6(s, &x)) return false;
#ifdef VMOVSIGN32
    y = VSHL32(x, 31);
    x = glue12(x);
    *e = VMOVSIGN32(y);
#else
    y = VSHUF8(x, V8x16_C(
	     0,  4,  8, 12, -1, -1, -1, -1,
	    -1, -1, -1, -1, -1, -1, -1, -1));
    x = glue12(x);
    *e = (y[0] & 0x1010101) * 0x10204080 >> 28;
#endif
    x = glue24(x);
    VSTORE(v, VSHR32(x, 1));
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rsp, %rsi
callq 0x6bf8
testb %al, %al
je 0x26b8
vmovdqa (%rsp), %xmm0
vpmaddubsw 0x58b5(%rip), %xmm0, %xmm1 # 0x7f50
vpslld $0x1f, %xmm0, %xmm0
vmovmskps %xmm0, %ecx
movl %ecx, (%r14)
vpmaddwd 0x58b1(%rip), %xmm1, %xmm0 # 0x7f60
vpsrld $0x1, %xmm0, %xmm0
vmovdqu %xmm0, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack25x3c13e3o1
static inline bool unpack25x3c13e3o1(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x;
    if (!unpack24(s - 2, &x)) return false;
    x = VSHUF8(x, V8x16_C(
	     1,  2,  4,  5,  5, 6, 8,  9,
	    10, 12, 13, 14, 14, 5, 9, -1));
#ifdef VMOVSIGN32
    x = VSHLV32(x, 2, 0, 6, 0);
    *e = VMOVSIGN32(x);
    x = VSHR32(x, 6);
    VSTORE(v, VAND(x, VDUP32(Mask(25))));
#else
    x = VSHLV32(x, 3, 1, 7, 7);
    VSTORE(v, VSHR32(x, 7));
    *e = (v[3] & 0x802002) * 0x40010080 >> 29;
#endif
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
addq $-0x2, %rdi
movq %rsp, %rsi
callq 0x6c56
testb %al, %al
je 0x276e
vmovdqa (%rsp), %xmm0
vpshufb 0x5ca8(%rip), %xmm0, %xmm0 # 0x83f0
vpsllvd 0x5caf(%rip), %xmm0, %xmm0 # 0x8400
vmovmskps %xmm0, %ecx
movl %ecx, (%r14)
vpsrld $0x6, %xmm0, %xmm0
vpbroadcastq 0x5dd2(%rip), %xmm1 # 0x8538
vpand %xmm1, %xmm0, %xmm0
vmovdqu %xmm0, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack25x4c17e2
static inline bool unpack25x4c17e2(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x;
    if (!unpack24(s, &x)) return false;
    x = VSHUF8(x, V8x16_C(
	    0, 1,  2,  4,  4,  5,  6,  8,
	    8, 9, 10, 12, 12, 13, 14, -1));
    x = VSHLV32(x, 7, 6, 5, 4);
    VSTORE(v, VSHR32(x, 7));
    int32_t hi = base64dec1(s + 16);
    if (hi < 0) return false;
    v[3] |= (hi & Mask(4)) << 21;
    *e = (hi >> 4);
    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %rsi
callq 0x6c56
testb %al, %al
je 0x280b
vmovdqa (%rsp), %xmm0
vpshufb 0x5c51(%rip), %xmm0, %xmm0 # 0x8410
vpsrlvd 0x5c58(%rip), %xmm0, %xmm0 # 0x8420
vpbroadcastd 0x5d37(%rip), %xmm1 # 0x8508
vpand %xmm1, %xmm0, %xmm0
vmovdqu %xmm0, (%r14)
movzbl 0x10(%r15), %eax
leaq 0x486a(%rip), %rcx      # 0x7050
movsbl (%rax,%rcx), %eax
testl %eax, %eax
js 0x280b
vpextrd $0x3, %xmm0, %ecx
movl %eax, %edx
andl $0xf, %edx
shll $0x15, %edx
orl %ecx, %edx
movl %edx, 0xc(%r14)
shrl $0x4, %eax
movl %eax, (%rbx)
movb $0x1, %al
jmp 0x280d
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack26x3c13o1
static inline bool unpack26x3c13o1(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x;
    if (!unpack24(s - 2, &x)) return false;
    x = VSHUF8(x, V8x16_C(
	     1,  2,  4,  5,  5,  6,  8,  9,
	    10, 12, 13, 14, -1, -1, -1, -1));
    x = VSHLV32(x, 2, 0, 6, 0);
    VSTORE(v, VSHR32(x, 6));
    return (void) e, true;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
addq $-0x2, %rdi
movq %rsp, %rsi
callq 0x6c56
testb %al, %al
je 0x2874
vmovdqa (%rsp), %xmm0
vpshufb 0x5bd6(%rip), %xmm0, %xmm0 # 0x8430
vpsrlvd 0x5bdd(%rip), %xmm0, %xmm0 # 0x8440
vpbroadcastd 0x5ca0(%rip), %xmm1 # 0x850c
vpand %xmm1, %xmm0, %xmm0
vmovdqu %xmm0, (%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack26x4c18e4
static inline bool unpack26x4c18e4(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x;
    if (!unpack24(s, &x)) return false;
    x = VSHUF8(x, V8x16_C(
	    0, 1,  2,  4,  4,  5,  6,  8,
	    8, 9, 10, 12, 12, 13, 14, -1));
    x = VSHLV32(x, 6, 4, 2, 0);
    VSTORE(v, VSHR32(x, 6));
    int32_t hi = base64dec2(s + 16);
    if (hi < 0) return false;
    v[3] |= (hi & Mask(8)) << 18;
    *e = (hi >> 8);
    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %rsi
callq 0x6c56
testb %al, %al
je 0x291b
vmovdqa (%rsp), %xmm0
vpshufb 0x5b4d(%rip), %xmm0, %xmm0 # 0x8410
vpsrlvd 0x5b84(%rip), %xmm0, %xmm0 # 0x8450
vpbroadcastd 0x5c37(%rip), %xmm1 # 0x850c
vpand %xmm1, %xmm0, %xmm0
vmovdqu %xmm0, (%r14)
movzbl 0x10(%r15), %eax
movzbl 0x11(%r15), %ecx
leaq 0x4761(%rip), %rdx      # 0x7050
movsbl (%rax,%rdx), %eax
orw 0x100(%rdx,%rcx,2), %ax
js 0x291b
vpextrd $0x3, %xmm0, %ecx
movzwl %ax, %eax
movzbl %al, %edx
shll $0x12, %edx
orl %ecx, %edx
movl %edx, 0xc(%r14)
shrl $0x8, %eax
movl %eax, (%rbx)
movb $0x1, %al
jmp 0x291d
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack27x3c14e3
static inline bool unpack27x3c14e3(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x;
    if (!unpack24(s - 2, &x)) return false;
    x = VSHUF8(x, V8x16_C(
	     1,  2,  4,  5, 6,  8,  9, 10,
	    10, 12, 13, 14, 5, 10, 14, -1));
#ifdef VMOVSIGN32
    x = VBLEND16(x, VSHL32(x, 4), 0x0c);
    *e = VMOVSIGN32(x);
    x = VSHR32(x, 4);
    VSTORE(v, VAND(x, VDUP32(Mask(27))));
#else
    x = VSHLV32(x, 1, 5, 1, 1);
    VSTORE(v, VSHR32(x, 5));
    *e = (v[3] & 0x80088) * 0x4801000 >> 29;
#endif
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
addq $-0x2, %rdi
movq %rsp, %rsi
callq 0x6c56
testb %al, %al
je 0x2997
vmovdqa (%rsp), %xmm0
vpshufb 0x5af1(%rip), %xmm0, %xmm0 # 0x8460
vpslld $0x4, %xmm0, %xmm1
vpblendd $0x2, %xmm1, %xmm0, %xmm0 # xmm0 = xmm0[0],xmm1[1],xmm0[2,3]
vmovmskps %xmm0, %ecx
movl %ecx, (%r14)
vpsrld $0x4, %xmm0, %xmm0
vpbroadcastq 0x5bb1(%rip), %xmm1 # 0x8540
vpand %xmm1, %xmm0, %xmm0
vmovdqu %xmm0, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack27x4c18
static inline bool unpack27x4c18(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x;
    if (!unpack24(s, &x)) return false;
    x = VSHUF8(x, V8x16_C(
	    0, 1,  2,  4,  4,  5,  6,  8,
	    8, 9, 10, 12, 13, 14, -1, -1));
#ifdef VSHRV64
    x = VSHRV64(x, 0, 1);
#else
    x = VBLEND16(x, VSHR64(x, 1), 0xf0);
#endif
    x = VSHLV32(x, 5, 2, 0, 17);
    VSTORE(v, VSHR32(x, 5));
    int32_t lo = base64dec2(s + 16);
    if (lo < 0) return false;
    v[3] |= lo;
    return (void) e, true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %rsi
callq 0x6c56
testb %al, %al
je 0x2a31
vmovdqa (%rsp), %xmm0
vpshufb 0x5a8d(%rip), %xmm0, %xmm0 # 0x8470
vpsrlq $0x1, %xmm0, %xmm1
vpblendd $0xc, %xmm1, %xmm0, %xmm0 # xmm0 = xmm0[0,1],xmm1[2,3]
vpsllvd 0x5a89(%rip), %xmm0, %xmm0 # 0x8480
vpsrld $0x5, %xmm0, %xmm0
vmovdqu %xmm0, (%rbx)
movzbl 0x10(%r14), %eax
movzbl 0x11(%r14), %ecx
leaq 0x463f(%rip), %rdx      # 0x7050
movsbl (%rax,%rdx), %eax
orw 0x100(%rdx,%rcx,2), %ax
js 0x2a31
vpextrd $0x3, %xmm0, %ecx
movzwl %ax, %eax
orl %eax, %ecx
movl %ecx, 0xc(%rbx)
movb $0x1, %al
jmp 0x2a33
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack28x3c14
static inline bool unpack28x3c14(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x;
    if (!unpack24(s - 2, &x)) return false;
    x = VSHUF8(x, V8x16_C(
	     1,  2,  4,  5,  6,  8,  9, 10,
	    10, 12, 13, 14, -1, -1, -1, -1));
#if VSHLV32_COST >= 2
    x = VBLEND16(x, VSHL32(x, 4), 0x0c);
#else
    x = VSHLV32(x, 0, 4, 0, 0);
#endif
    VSTORE(v, VSHR32(x, 4));
    return (void) e, true;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
addq $-0x2, %rdi
movq %rsp, %rsi
callq 0x6c56
testb %al, %al
je 0x2a92
vmovdqa (%rsp), %xmm0
vpshufb 0x5a12(%rip), %xmm0, %xmm0 # 0x8490
vpslld $0x4, %xmm0, %xmm1
vpblendd $0x2, %xmm1, %xmm0, %xmm0 # xmm0 = xmm0[0],xmm1[1],xmm0[2,3]
vpsrld $0x4, %xmm0, %xmm0
vmovdqu %xmm0, (%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack29x3c15e3o1
static inline bool unpack29x3c15e3o1(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x, y;
    if (!unpack6(s, &x)) return false;
    y = glue12(x);
    x = VSHUF8(x, V8x16_C(
	    -1, -1, -1, 12, -1, -1, -1, 13,
	    -1, -1, -1, 14, -1, -1, -1, -1));
#ifdef VMOVSIGN32
    *e = VMOVSIGN32(VSHL32(x, 2));
    y = glue24(y);
#else
    y = glue24(y);
    *e = (y[3] & 0x20820) * 0x1084000 >> 29;
#endif
    x = VOR(x, y);
    VSTORE(v, VAND(x, VDUP32(Mask(29))));
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rsp, %rsi
callq 0x6bf8
testb %al, %al
je 0x2b0e
vmovdqa (%rsp), %xmm0
vpmaddubsw 0x5474(%rip), %xmm0, %xmm1 # 0x7f50
vpshufb 0x59bb(%rip), %xmm0, %xmm0 # 0x84a0
vpslld $0x2, %xmm0, %xmm2
vmovmskps %xmm2, %ecx
movl %ecx, (%r14)
vpmaddwd 0x5467(%rip), %xmm1, %xmm1 # 0x7f60
vpor %xmm0, %xmm1, %xmm0
vpbroadcastq 0x5a42(%rip), %xmm1 # 0x8548
vpand %xmm1, %xmm0, %xmm0
vmovdqu %xmm0, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack30x3c15o1
static inline bool unpack30x3c15o1(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x, y;
    if (!unpack6(s, &x)) return false;
    y = glue12(x);
    x = VSHUF8(x, V8x16_C(
	    -1, -1, -1, 12, -1, -1, -1, 13,
	    -1, -1, -1, 14, -1, -1, -1, -1));
    y = glue24(y);
    VSTORE(v, VOR(x, y));
    return (void) e, true;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rsp, %rsi
callq 0x6bf8
testb %al, %al
je 0x2b6e
vmovdqa (%rsp), %xmm0
vpmaddubsw 0x53fb(%rip), %xmm0, %xmm1 # 0x7f50
vpshufb 0x5942(%rip), %xmm0, %xmm0 # 0x84a0
vpmaddwd 0x53fa(%rip), %xmm1, %xmm1 # 0x7f60
vpor %xmm0, %xmm1, %xmm0
vmovdqu %xmm0, (%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64pack.h
// Function: pack15x6c15
static inline void pack15x6c15(const uint32_t *v, char *s, unsigned e)
{
    s[ 0] = base64[(v[0] & Mask( 6))];
    s[ 1] = base64[(v[0] & Mask(12)) >>  6];
    s[ 2] = base64[(v[0] & Mask(15)) >> 12 |
		   (v[1] & Mask( 3)) <<  3];
    s[ 3] = base64[(v[1] & Mask( 9)) >>  3];
    s[ 4] = base64[(v[1] & Mask(15)) >>  9];
    s[ 5] = base64[(v[2] & Mask( 6))];
    s[ 6] = base64[(v[2] & Mask(12)) >>  6];
    s[ 7] = base64[(v[2] & Mask(15)) >> 12 |
		   (v[3] & Mask( 3)) <<  3];
    s[ 8] = base64[(v[3] & Mask( 9)) >>  3];
    s[ 9] = base64[(v[3] & Mask(15)) >>  9];
    s[10] = base64[(v[4] & Mask( 6))];
    s[11] = base64[(v[4] & Mask(12)) >>  6];
    s[12] = base64[(v[4] & Mask(15)) >> 12 |
		   (v[5] & Mask( 3)) <<  3];
    s[13] = base64[(v[5] & Mask( 9)) >>  3];
    s[14] = base64[(v[5] & Mask(15)) >>  9];
    (void) e;
}

// Assembly:
movl (%rdi), %ecx
andl $0x3f, %ecx
leaq 0x1ad7(%rip), %rax      # 0x7010
movb (%rcx,%rax), %cl
movb %cl, (%rsi)
movl (%rdi), %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x1(%rsi)
movl (%rdi), %ecx
movl 0x4(%rdi), %edx
shrl $0xc, %ecx
andl $0x7, %ecx
andl $0x7, %edx
leal (%rcx,%rdx,8), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x2(%rsi)
movl 0x4(%rdi), %ecx
shrl $0x3, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x3(%rsi)
movl 0x4(%rdi), %ecx
shrl $0x9, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x4(%rsi)
movl 0x8(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x5(%rsi)
movl 0x8(%rdi), %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x6(%rsi)
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %edx
shrl $0xc, %ecx
andl $0x7, %ecx
andl $0x7, %edx
leal (%rcx,%rdx,8), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x7(%rsi)
movl 0xc(%rdi), %ecx
shrl $0x3, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x8(%rsi)
movl 0xc(%rdi), %ecx
shrl $0x9, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x9(%rsi)
movl 0x10(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xa(%rsi)
movl 0x10(%rdi), %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xb(%rsi)
movl 0x10(%rdi), %ecx
movl 0x14(%rdi), %edx
shrl $0xc, %ecx
andl $0x7, %ecx
andl $0x7, %edx
leal (%rcx,%rdx,8), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xc(%rsi)
movl 0x14(%rdi), %ecx
shrl $0x3, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xd(%rsi)
movl 0x14(%rdi), %ecx
shrl $0x9, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %al
movb %al, 0xe(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64pack.h
// Function: pack16x6c16
static inline void pack16x6c16(const uint32_t *v, char *s, unsigned e)
{
    s[ 0] = base64[(v[0] & Mask( 6))];
    s[ 1] = base64[(v[0] & Mask(12)) >>  6];
    s[ 2] = base64[(v[0] & Mask(16)) >> 12 |
		   (v[1] & Mask( 2)) <<  4];
    s[ 3] = base64[(v[1] & Mask( 8)) >>  2];
    s[ 4] = base64[(v[1] & Mask(14)) >>  8];
    s[ 5] = base64[(v[1] & Mask(16)) >> 14 |
		   (v[2] & Mask( 4)) <<  2];
    s[ 6] = base64[(v[2] & Mask(10)) >>  4];
    s[ 7] = base64[(v[2] & Mask(16)) >> 10];
    s[ 8] = base64[(v[3] & Mask( 6))];
    s[ 9] = base64[(v[3] & Mask(12)) >>  6];
    s[10] = base64[(v[3] & Mask(16)) >> 12 |
		   (v[4] & Mask( 2)) <<  4];
    s[11] = base64[(v[4] & Mask( 8)) >>  2];
    s[12] = base64[(v[4] & Mask(14)) >>  8];
    s[13] = base64[(v[4] & Mask(16)) >> 14 |
		   (v[5] & Mask( 4)) <<  2];
    s[14] = base64[(v[5] & Mask(10)) >>  4];
    s[15] = base64[(v[5] & Mask(16)) >> 10];
    (void) e;
}

// Assembly:
movl (%rdi), %ecx
andl $0x3f, %ecx
leaq 0x19e0(%rip), %rax      # 0x7010
movb (%rcx,%rax), %cl
movb %cl, (%rsi)
movl (%rdi), %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x1(%rsi)
movl (%rdi), %ecx
movl 0x4(%rdi), %edx
shrl $0xc, %ecx
andl $0xf, %ecx
shll $0x4, %edx
andl $0x30, %edx
orl %ecx, %edx
movb (%rdx,%rax), %cl
movb %cl, 0x2(%rsi)
movl 0x4(%rdi), %ecx
shrl $0x2, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x3(%rsi)
movl 0x4(%rdi), %ecx
shrl $0x8, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x4(%rsi)
movl 0x4(%rdi), %ecx
movl 0x8(%rdi), %edx
shrl $0xe, %ecx
andl $0x3, %ecx
andl $0xf, %edx
leal (%rcx,%rdx,4), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x5(%rsi)
movl 0x8(%rdi), %ecx
shrl $0x4, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x6(%rsi)
movl 0x8(%rdi), %ecx
shrl $0xa, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x7(%rsi)
movl 0xc(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x8(%rsi)
movl 0xc(%rdi), %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x9(%rsi)
movl 0xc(%rdi), %ecx
movl 0x10(%rdi), %edx
shrl $0xc, %ecx
andl $0xf, %ecx
shll $0x4, %edx
andl $0x30, %edx
orl %ecx, %edx
movb (%rdx,%rax), %cl
movb %cl, 0xa(%rsi)
movl 0x10(%rdi), %ecx
shrl $0x2, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xb(%rsi)
movl 0x10(%rdi), %ecx
shrl $0x8, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xc(%rsi)
movl 0x10(%rdi), %ecx
movl 0x14(%rdi), %edx
shrl $0xe, %ecx
andl $0x3, %ecx
andl $0xf, %edx
leal (%rcx,%rdx,4), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xd(%rsi)
movl 0x14(%rdi), %ecx
shrl $0x4, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xe(%rsi)
movl 0x14(%rdi), %ecx
shrl $0xa, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %al
movb %al, 0xf(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64pack.h
// Function: pack21x4c14
static inline void pack21x4c14(const uint32_t *v, char *s, unsigned e)
{
    s[ 0] = base64[ v[0] & Mask( 6)];
    s[ 1] = base64[(v[0] & Mask(12)) >>  6];
    s[ 2] = base64[(v[0] & Mask(18)) >> 12];
    s[ 3] = base64[(v[0] & Mask(21)) >> 18 |
		   (v[1] & Mask( 3)) <<  3];
    s[ 4] = base64[(v[1] & Mask( 9)) >>  3];
    s[ 5] = base64[(v[1] & Mask(15)) >>  9];
    s[ 6] = base64[(v[1] & Mask(21)) >> 15];
    s[ 7] = base64[ v[2] & Mask( 6)];
    s[ 8] = base64[(v[2] & Mask(12)) >>  6];
    s[ 9] = base64[(v[2] & Mask(18)) >> 12];
    s[10] = base64[(v[2] & Mask(21)) >> 18 |
		   (v[3] & Mask( 3)) <<  3];
    s[11] = base64[(v[3] & Mask( 9)) >>  3];
    s[12] = base64[(v[3] & Mask(15)) >>  9];
    s[13] = base64[(v[3] & Mask(21)) >> 15];
    (void) e;
}

// Assembly:
movl (%rdi), %ecx
andl $0x3f, %ecx
leaq 0x10fe(%rip), %rax      # 0x7010
movb (%rcx,%rax), %cl
movb %cl, (%rsi)
movl (%rdi), %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x1(%rsi)
movl (%rdi), %ecx
shrl $0xc, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x2(%rsi)
movl (%rdi), %ecx
movl 0x4(%rdi), %edx
shrl $0x12, %ecx
andl $0x7, %ecx
andl $0x7, %edx
leal (%rcx,%rdx,8), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x3(%rsi)
movl 0x4(%rdi), %ecx
shrl $0x3, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x4(%rsi)
movl 0x4(%rdi), %ecx
shrl $0x9, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x5(%rsi)
movl 0x4(%rdi), %ecx
shrl $0xf, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x6(%rsi)
movl 0x8(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x7(%rsi)
movl 0x8(%rdi), %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x8(%rsi)
movl 0x8(%rdi), %ecx
shrl $0xc, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x9(%rsi)
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %edx
shrl $0x12, %ecx
andl $0x7, %ecx
andl $0x7, %edx
leal (%rcx,%rdx,8), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xa(%rsi)
movl 0xc(%rdi), %ecx
shrl $0x3, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xb(%rsi)
movl 0xc(%rdi), %ecx
shrl $0x9, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xc(%rsi)
movl 0xc(%rdi), %ecx
shrl $0xf, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %al
movb %al, 0xd(%rsi)
retq