LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/svpv[P]rpmset/./base64pack.h
// Function: pack14x6c14
static inline void pack14x6c14(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(14)) >> 12 |
		   (v[1] & Mask( 4)) <<  2];
    s[ 3] = base64[(v[1] & Mask(10)) >>  4];
    s[ 4] = base64[(v[1] & Mask(14)) >> 10 |
		   (v[2] & Mask( 2)) <<  4];
    s[ 5] = base64[(v[2] & Mask( 8)) >>  2];
    s[ 6] = base64[(v[2] & Mask(14)) >>  8];
    s[ 7] = base64[(v[3] & Mask( 6))];
    s[ 8] = base64[(v[3] & Mask(12)) >>  6];
    s[ 9] = base64[(v[3] & Mask(14)) >> 12 |
		   (v[4] & Mask( 4)) <<  2];
    s[10] = base64[(v[4] & Mask(10)) >>  4];
    s[11] = base64[(v[4] & Mask(14)) >> 10 |
		   (v[5] & Mask( 2)) <<  4];
    s[12] = base64[(v[5] & Mask( 8)) >>  2];
    s[13] = base64[(v[5] & Mask(14)) >>  8];
    (void) e;
}

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

// Assembly:
movl 0x4(%rdi), %r8d
movl 0x10(%rdi), %r9d
movl $0x3c0, %ecx            # imm = 0x3C0
movl %r8d, %eax
andl %ecx, %eax
shrl $0x4, %r9d
andl $0x1c00, %r9d           # imm = 0x1C00
andl $0x1f, %edx
shll $0xd, %edx
orl %r9d, %edx
orl %eax, %r9d
andl $0x3f, %r8d
leaq 0x2271(%rip), %rax      # 0x9010
movb (%r8,%rax), %r8b
movb %r8b, (%rsi)
shrl $0x6, %r9d
andl $0x3f, %r9d
movb (%r9,%rax), %r8b
movb %r8b, 0x1(%rsi)
shrl $0xc, %edx
movb (%rdx,%rax), %dl
movb %dl, 0x2(%rsi)
movl (%rdi), %edx
movl 0x4(%rdi), %r8d
shrl $0xa, %r8d
movl %r8d, %r9d
andl $0x40, %r9d
movl %edx, %r10d
shll $0x7, %r10d
orl %r9d, %r10d
andl $0x3f, %r8d
movb (%r8,%rax), %r8b
movb %r8b, 0x3(%rsi)
shrl $0x6, %r10d
andl $0x3f, %r10d
movb (%r10,%rax), %r8b
movb %r8b, 0x4(%rsi)
movl %edx, %r8d
shrl $0x5, %r8d
andl $0x3f, %r8d
movb (%r8,%rax), %r8b
movb %r8b, 0x5(%rsi)
shrl $0xb, %edx
andl $0x3f, %edx
movb (%rdx,%rax), %dl
movb %dl, 0x6(%rsi)
movl 0x8(%rdi), %r8d
movl 0xc(%rdi), %edx
movl %r8d, %r9d
andl $0x1f000, %r9d          # imm = 0x1F000
movl %edx, %r10d
shll $0x11, %r10d
orl %r9d, %r10d
movl %r8d, %r9d
andl $0x3f, %r9d
movb (%r9,%rax), %r9b
movb %r9b, 0x7(%rsi)
shrl $0x6, %r8d
andl $0x3f, %r8d
movb (%r8,%rax), %r8b
movb %r8b, 0x8(%rsi)
shrl $0xc, %r10d
andl $0x3f, %r10d
movb (%r10,%rax), %r8b
movb %r8b, 0x9(%rsi)
shrl %edx
andl $0x3f, %edx
movb (%rdx,%rax), %dl
movb %dl, 0xa(%rsi)
movl 0xc(%rdi), %r8d
movl 0x10(%rdi), %edx
shrl $0x7, %r8d
andl %r8d, %ecx
movl %edx, %edi
shll $0xa, %edi
orl %ecx, %edi
andl $0x3f, %r8d
movb (%r8,%rax), %cl
movb %cl, 0xb(%rsi)
shrl $0x6, %edi
andl $0x3f, %edi
movb (%rdi,%rax), %cl
movb %cl, 0xc(%rsi)
movl %edx, %ecx
shrl $0x2, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xd(%rsi)
shrl $0x8, %edx
andl $0x3f, %edx
movb (%rdx,%rax), %al
movb %al, 0xe(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/svpv[P]rpmset/./base64pack.h
// Function: pack17x6c17
static inline void pack17x6c17(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(17)) >> 12 |
		   (v[1] & Mask( 1)) <<  5];
    s[ 3] = base64[(v[1] & Mask( 7)) >>  1];
    s[ 4] = base64[(v[1] & Mask(13)) >>  7];
    s[ 5] = base64[(v[1] & Mask(17)) >> 13 |
		   (v[2] & Mask( 2)) <<  4];
    s[ 6] = base64[(v[2] & Mask( 8)) >>  2];
    s[ 7] = base64[(v[2] & Mask(14)) >>  8];
    s[ 8] = base64[(v[2] & Mask(17)) >> 14 |
		   (v[3] & Mask( 3)) <<  3];
    s[ 9] = base64[(v[3] & Mask( 9)) >>  3];
    s[10] = base64[(v[3] & Mask(15)) >>  9];
    s[11] = base64[(v[3] & Mask(17)) >> 15 |
		   (v[4] & Mask( 4)) <<  2];
    s[12] = base64[(v[4] & Mask(10)) >>  4];
    s[13] = base64[(v[4] & Mask(16)) >> 10];
    s[14] = base64[(v[4] & Mask(17)) >> 16 |
		   (v[5] & Mask( 5)) <<  1];
    s[15] = base64[(v[5] & Mask(11)) >>  5];
    s[16] = base64[(v[5] & Mask(17)) >> 11];
    (void) e;
}

// Assembly:
movl (%rdi), %ecx
andl $0x3f, %ecx
leaq 0x2153(%rip), %rax      # 0x9010
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 $0x1f, %ecx
shll $0x5, %edx
andl $0x20, %edx
orl %ecx, %edx
movb (%rdx,%rax), %cl
movb %cl, 0x2(%rsi)
movl 0x4(%rdi), %ecx
shrl %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x3(%rsi)
movl 0x4(%rdi), %ecx
shrl $0x7, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x4(%rsi)
movl 0x4(%rdi), %ecx
movl 0x8(%rdi), %edx
shrl $0xd, %ecx
andl $0xf, %ecx
shll $0x4, %edx
andl $0x30, %edx
orl %ecx, %edx
movb (%rdx,%rax), %cl
movb %cl, 0x5(%rsi)
movl 0x8(%rdi), %ecx
shrl $0x2, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x6(%rsi)
movl 0x8(%rdi), %ecx
shrl $0x8, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x7(%rsi)
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %edx
shrl $0xe, %ecx
andl $0x7, %ecx
andl $0x7, %edx
leal (%rcx,%rdx,8), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x8(%rsi)
movl 0xc(%rdi), %ecx
shrl $0x3, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x9(%rsi)
movl 0xc(%rdi), %ecx
shrl $0x9, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xa(%rsi)
movl 0xc(%rdi), %ecx
movl 0x10(%rdi), %edx
shrl $0xf, %ecx
andl $0x3, %ecx
andl $0xf, %edx
leal (%rcx,%rdx,4), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xb(%rsi)
movl 0x10(%rdi), %ecx
shrl $0x4, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xc(%rsi)
movl 0x10(%rdi), %ecx
shrl $0xa, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xd(%rsi)
movzwl 0x12(%rdi), %ecx
andl $0x1, %ecx
movl 0x14(%rdi), %edx
andl $0x1f, %edx
leaq (%rcx,%rdx,2), %rcx
movb (%rax,%rcx), %cl
movb %cl, 0xe(%rsi)
movl 0x14(%rdi), %ecx
shrl $0x5, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xf(%rsi)
movl 0x14(%rdi), %ecx
shrl $0xb, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %al
movb %al, 0x10(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/svpv[P]rpmset/./base64pack.h
// Function: pack18x5c15
static inline void pack18x5c15(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[1] & Mask( 6))];
    s[ 4] = base64[(v[1] & Mask(12)) >>  6];
    s[ 5] = base64[(v[1] & Mask(18)) >> 12];
    s[ 6] = base64[(v[2] & Mask( 6))];
    s[ 7] = base64[(v[2] & Mask(12)) >>  6];
    s[ 8] = base64[(v[2] & Mask(18)) >> 12];
    s[ 9] = base64[(v[3] & Mask( 6))];
    s[10] = base64[(v[3] & Mask(12)) >>  6];
    s[11] = base64[(v[3] & Mask(18)) >> 12];
    s[12] = base64[(v[4] & Mask( 6))];
    s[13] = base64[(v[4] & Mask(12)) >>  6];
    s[14] = base64[(v[4] & Mask(18)) >> 12];
    (void) e;
}

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

// Assembly:
andl $0x3, %edx
movl (%rdi), %eax
andl $0xf, %eax
leal (%rdx,%rax,4), %ecx
leaq 0x1f48(%rip), %rax      # 0x9010
movb (%rcx,%rax), %cl
movb %cl, (%rsi)
movl (%rdi), %ecx
shrl $0x4, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x1(%rsi)
movl (%rdi), %ecx
shrl $0xa, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x2(%rsi)
movzwl 0x2(%rdi), %ecx
andl $0x7, %ecx
movl 0x4(%rdi), %edx
andl $0x7, %edx
leaq (%rcx,%rdx,8), %rcx
movb (%rax,%rcx), %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
movl 0x8(%rdi), %edx
shrl $0xf, %ecx
andl $0xf, %ecx
shll $0x4, %edx
andl $0x30, %edx
orl %ecx, %edx
movb (%rdx,%rax), %cl
movb %cl, 0x6(%rsi)
movl 0x8(%rdi), %ecx
shrl $0x2, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x7(%rsi)
movl 0x8(%rdi), %ecx
shrl $0x8, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x8(%rsi)
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %edx
shrl $0xe, %ecx
andl $0x1f, %ecx
shll $0x5, %edx
andl $0x20, %edx
orl %ecx, %edx
movb (%rdx,%rax), %cl
movb %cl, 0x9(%rsi)
movl 0xc(%rdi), %ecx
shrl %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xa(%rsi)
movl 0xc(%rdi), %ecx
shrl $0x7, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xb(%rsi)
movl 0xc(%rdi), %ecx
shrl $0xd, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %al
movb %al, 0xc(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/svpv[P]rpmset/./base64pack.h
// Function: pack19x5c16e1
static inline void pack19x5c16e1(const uint32_t *v, char *s, unsigned e)
{
    s[ 0] = base64[(  e  & Mask( 1))       |
		   (v[0] & Mask( 5)) <<  1];
    s[ 1] = base64[(v[0] & Mask(11)) >>  5];
    s[ 2] = base64[(v[0] & Mask(17)) >> 11];
    s[ 3] = base64[(v[0] & Mask(19)) >> 17 |
		   (v[1] & Mask( 4)) <<  2];
    s[ 4] = base64[(v[1] & Mask(10)) >>  4];
    s[ 5] = base64[(v[1] & Mask(16)) >> 10];
    s[ 6] = base64[(v[1] & Mask(19)) >> 16 |
		   (v[2] & Mask( 3)) <<  3];
    s[ 7] = base64[(v[2] & Mask( 9)) >>  3];
    s[ 8] = base64[(v[2] & Mask(15)) >>  9];
    s[ 9] = base64[(v[2] & Mask(19)) >> 15 |
		   (v[3] & Mask( 2)) <<  4];
    s[10] = base64[(v[3] & Mask( 8)) >>  2];
    s[11] = base64[(v[3] & Mask(14)) >>  8];
    s[12] = base64[(v[3] & Mask(19)) >> 14 |
		   (v[4] & Mask( 1)) <<  5];
    s[13] = base64[(v[4] & Mask( 7)) >>  1];
    s[14] = base64[(v[4] & Mask(13)) >>  7];
    s[15] = base64[(v[4] & Mask(19)) >> 13];
}

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

// Assembly:
andl $0xf, %edx
movl (%rdi), %ecx
shll $0x4, %ecx
andl $0x30, %ecx
orl %edx, %ecx
leaq 0x1d43(%rip), %rax      # 0x9010
movb (%rcx,%rax), %cl
movb %cl, (%rsi)
movl (%rdi), %ecx
shrl $0x2, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x1(%rsi)
movl (%rdi), %ecx
shrl $0x8, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x2(%rsi)
movl (%rdi), %ecx
shrl $0xe, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x3(%rsi)
movl 0x4(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x4(%rsi)
movl 0x4(%rdi), %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x5(%rsi)
movl 0x4(%rdi), %ecx
shrl $0xc, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x6(%rsi)
movl 0x4(%rdi), %ecx
movl 0x8(%rdi), %edx
shrl $0x12, %ecx
andl $0x3, %ecx
andl $0xf, %edx
leal (%rcx,%rdx,4), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x7(%rsi)
movl 0x8(%rdi), %ecx
shrl $0x4, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x8(%rsi)
movl 0x8(%rdi), %ecx
shrl $0xa, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x9(%rsi)
movzwl 0xa(%rdi), %ecx
andl $0xf, %ecx
movl 0xc(%rdi), %edx
shll $0x4, %edx
andl $0x30, %edx
orq %rcx, %rdx
movb (%rax,%rdx), %cl
movb %cl, 0xa(%rsi)
movl 0xc(%rdi), %ecx
shrl $0x2, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xb(%rsi)
movl 0xc(%rdi), %ecx
shrl $0x8, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xc(%rsi)
movl 0xc(%rdi), %ecx
shrl $0xe, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %al
movb %al, 0xd(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1acd(%rip), %rax      # 0x9010
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
// File: /workspace/github_c_makefile_star2_O1/svpv[P]rpmset/./base64pack.h
// Function: pack22x4c15e2
static inline void pack22x4c15e2(const uint32_t *v, char *s, unsigned e)
{
    uint32_t x = (v[0] & Mask(10))
	       | (v[3] & Mask(22)) >> 16 << 10
	       | (  e  & Mask( 2)) << 16;
    s[ 0] = base64[(x & Mask( 6))];
    s[ 1] = base64[(x & Mask(12)) >>  6];
    s[ 2] = base64[(x >> 12)];
    s[ 3] = base64[(v[0] & Mask(16)) >> 10];
    s[ 4] = base64[(v[0] & Mask(22)) >> 16];
    s[ 5] = base64[ v[1] & Mask( 6)];
    s[ 6] = base64[(v[1] & Mask(12)) >>  6];
    s[ 7] = base64[(v[1] & Mask(18)) >> 12];
    s[ 8] = base64[(v[1] & Mask(22)) >> 18 |
		   (v[2] & Mask( 2)) <<  4];
    s[ 9] = base64[(v[2] & Mask( 8)) >>  2];
    s[10] = base64[(v[2] & Mask(14)) >>  8];
    s[11] = base64[(v[2] & Mask(20)) >> 14];
    s[12] = base64[(v[2] & Mask(22)) >> 20 |
		   (v[3] & Mask( 4)) <<  2];
    s[13] = base64[(v[3] & Mask(10)) >>  4];
    s[14] = base64[(v[3] & Mask(16)) >> 10];
}

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

// Assembly:
movl (%rdi), %eax
andl $0x1f, %eax
movl %edx, %ecx
andl $0x1, %ecx
leal (%rcx,%rax,2), %ecx
leaq 0x18d6(%rip), %rax      # 0x9010
movb (%rcx,%rax), %cl
movb %cl, (%rsi)
movl (%rdi), %ecx
shrl $0x5, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x1(%rsi)
movl (%rdi), %ecx
shrl $0xb, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x2(%rsi)
movl (%rdi), %ecx
shrl $0x11, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x3(%rsi)
movl 0x4(%rdi), %ecx
andl $0x1f, %ecx
movl %edx, %r8d
shrl %r8d
andl $0x1, %r8d
leal (%r8,%rcx,2), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x4(%rsi)
movl 0x4(%rdi), %ecx
shrl $0x5, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x5(%rsi)
movl 0x4(%rdi), %ecx
shrl $0xb, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x6(%rsi)
movl 0x4(%rdi), %ecx
shrl $0x11, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x7(%rsi)
movl 0x8(%rdi), %ecx
andl $0x1f, %ecx
movl %edx, %r8d
shrl $0x2, %r8d
andl $0x1, %r8d
leal (%r8,%rcx,2), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x8(%rsi)
movl 0x8(%rdi), %ecx
shrl $0x5, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x9(%rsi)
movl 0x8(%rdi), %ecx
shrl $0xb, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xa(%rsi)
movl 0x8(%rdi), %ecx
shrl $0x11, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xb(%rsi)
movl 0xc(%rdi), %ecx
andl $0x1f, %ecx
shrl $0x3, %edx
andl $0x1, %edx
leal (%rdx,%rcx,2), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xc(%rsi)
movl 0xc(%rdi), %ecx
shrl $0x5, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xd(%rsi)
movl 0xc(%rdi), %ecx
shrl $0xb, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xe(%rsi)
movl 0xc(%rdi), %ecx
shrl $0x11, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %al
movb %al, 0xf(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/svpv[P]rpmset/./base64pack.h
// Function: pack24x4c16
static inline void pack24x4c16(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(24)) >> 18];
    s[ 4] = base64[ v[1] & Mask( 6)];
    s[ 5] = base64[(v[1] & Mask(12)) >>  6];
    s[ 6] = base64[(v[1] & Mask(18)) >> 12];
    s[ 7] = base64[(v[1] & Mask(24)) >> 18];
    s[ 8] = base64[ v[2] & Mask( 6)];
    s[ 9] = base64[(v[2] & Mask(12)) >>  6];
    s[10] = base64[(v[2] & Mask(18)) >> 12];
    s[11] = base64[(v[2] & Mask(24)) >> 18];
    s[12] = base64[ v[3] & Mask( 6)];
    s[13] = base64[(v[3] & Mask(12)) >>  6];
    s[14] = base64[(v[3] & Mask(18)) >> 12];
    s[15] = base64[(v[3] & Mask(24)) >> 18];
    (void) e;
}

// Assembly:
movl (%rdi), %ecx
andl $0x3f, %ecx
leaq 0x17c9(%rip), %rax      # 0x9010
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
shrl $0x12, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x3(%rsi)
movl 0x4(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x4(%rsi)
movl 0x4(%rdi), %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x5(%rsi)
movl 0x4(%rdi), %ecx
shrl $0xc, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x6(%rsi)
movl 0x4(%rdi), %ecx
shrl $0x12, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x7(%rsi)
movl 0x8(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x8(%rsi)
movl 0x8(%rdi), %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x9(%rsi)
movl 0x8(%rdi), %ecx
shrl $0xc, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xa(%rsi)
movl 0x8(%rdi), %ecx
shrl $0x12, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xb(%rsi)
movl 0xc(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xc(%rsi)
movl 0xc(%rdi), %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xd(%rsi)
movl 0xc(%rdi), %ecx
shrl $0xc, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xe(%rsi)
movl 0xc(%rdi), %ecx
shrl $0x12, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %al
movb %al, 0xf(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/svpv[P]rpmset/./base64pack.h
// Function: pack25x3c13e3
static inline void pack25x3c13e3(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(24)) >> 18];
    s[ 4] = base64[(v[0] & Mask(25)) >> 24 | (e & 1) << 1 |
		   (v[1] & Mask( 4)) <<  2];
    s[ 5] = base64[(v[1] & Mask(10)) >>  4];
    s[ 6] = base64[(v[1] & Mask(16)) >> 10];
    s[ 7] = base64[(v[1] & Mask(22)) >> 16];
    s[ 8] = base64[(v[1] & Mask(25)) >> 22 | (e & 2) << 2 |
		   (v[2] & Mask( 2)) <<  4];
    s[ 9] = base64[(v[2] & Mask( 8)) >>  2];
    s[10] = base64[(v[2] & Mask(14)) >>  8];
    s[11] = base64[(v[2] & Mask(20)) >> 14];
    s[12] = base64[(v[2] & Mask(25)) >> 20 | (e & 4) << 3];
}

// Assembly:
movl (%rdi), %ecx
andl $0x3f, %ecx
leaq 0x16e2(%rip), %rax      # 0x9010
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
shrl $0x12, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x3(%rsi)
movl (%rdi), %ecx
movl 0x4(%rdi), %r8d
shrl $0x18, %ecx
andl $0x1, %ecx
movl %edx, %r9d
andl $0x1, %r9d
leal (%rcx,%r9,2), %ecx
andl $0xf, %r8d
leal (%rcx,%r8,4), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x4(%rsi)
movl 0x4(%rdi), %ecx
shrl $0x4, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x5(%rsi)
movl 0x4(%rdi), %ecx
shrl $0xa, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x6(%rsi)
movzwl 0x6(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x7(%rsi)
movl 0x4(%rdi), %ecx
movl 0x8(%rdi), %r8d
shrl $0x16, %ecx
andl $0x7, %ecx
movl %edx, %r9d
andl $0x2, %r9d
leal (%rcx,%r9,4), %ecx
shll $0x4, %r8d
andl $0x30, %r8d
orl %ecx, %r8d
movb (%r8,%rax), %cl
movb %cl, 0x8(%rsi)
movl 0x8(%rdi), %ecx
shrl $0x2, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x9(%rsi)
movl 0x8(%rdi), %ecx
shrl $0x8, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xa(%rsi)
movl 0x8(%rdi), %ecx
shrl $0xe, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xb(%rsi)
movl 0x8(%rdi), %ecx
shrl $0x14, %ecx
andl $0x1f, %ecx
andl $0x4, %edx
leal (%rcx,%rdx,8), %ecx
movb (%rcx,%rax), %al
movb %al, 0xc(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/svpv[P]rpmset/./base64pack.h
// Function: pack25x4c17e2
static inline void pack25x4c17e2(const uint32_t *v, char *s, unsigned e)
{
    // 66661|56662|46663|36664|2
    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(24)) >> 18];
    s[ 4] = base64[(v[0] & Mask(25)) >> 24 |
		   (v[1] & Mask( 5)) <<  1];
    s[ 5] = base64[(v[1] & Mask(11)) >>  5];
    s[ 6] = base64[(v[1] & Mask(17)) >> 11];
    s[ 7] = base64[(v[1] & Mask(23)) >> 17];
    s[ 8] = base64[(v[1] & Mask(25)) >> 23 |
		   (v[2] & Mask( 4)) <<  2];
    s[ 9] = base64[(v[2] & Mask(10)) >>  4];
    s[10] = base64[(v[2] & Mask(16)) >> 10];
    s[11] = base64[(v[2] & Mask(22)) >> 16];
    s[12] = base64[(v[2] & Mask(25)) >> 22 |
		   (v[3] & Mask( 3)) <<  3];
    s[13] = base64[(v[3] & Mask( 9)) >>  3];
    s[14] = base64[(v[3] & Mask(15)) >>  9];
    s[15] = base64[(v[3] & Mask(21)) >> 15];
    s[16] = base64[(v[3] & Mask(25)) >> 21 |
		   (  e  & Mask( 2)) <<  4];
}

// Assembly:
movl (%rdi), %ecx
andl $0x3f, %ecx
leaq 0x15ea(%rip), %rax      # 0x9010
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
shrl $0x12, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x3(%rsi)
movzbl 0x3(%rdi), %ecx
andl $0x1, %ecx
movl 0x4(%rdi), %r8d
andl $0x1f, %r8d
leaq (%rcx,%r8,2), %rcx
movb (%rax,%rcx), %cl
movb %cl, 0x4(%rsi)
movl 0x4(%rdi), %ecx
shrl $0x5, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x5(%rsi)
movl 0x4(%rdi), %ecx
shrl $0xb, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x6(%rsi)
movl 0x4(%rdi), %ecx
shrl $0x11, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x7(%rsi)
movl 0x4(%rdi), %ecx
movl 0x8(%rdi), %r8d
shrl $0x17, %ecx
andl $0x3, %ecx
andl $0xf, %r8d
leal (%rcx,%r8,4), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x8(%rsi)
movl 0x8(%rdi), %ecx
shrl $0x4, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x9(%rsi)
movl 0x8(%rdi), %ecx
shrl $0xa, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xa(%rsi)
movzwl 0xa(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xb(%rsi)
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %r8d
shrl $0x16, %ecx
andl $0x7, %ecx
andl $0x7, %r8d
leal (%rcx,%r8,8), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xc(%rsi)
movl 0xc(%rdi), %ecx
shrl $0x3, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xd(%rsi)
movl 0xc(%rdi), %ecx
shrl $0x9, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xe(%rsi)
movl 0xc(%rdi), %ecx
shrl $0xf, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xf(%rsi)
movl 0xc(%rdi), %ecx
shrl $0x15, %ecx
andl $0xf, %ecx
shll $0x4, %edx
andl $0x30, %edx
orl %ecx, %edx
movb (%rdx,%rax), %al
movb %al, 0x10(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/svpv[P]rpmset/./base64pack.h
// Function: pack26x3c13
static inline void pack26x3c13(const uint32_t *v, char *s, unsigned e)
{
    // 66662|46664|26666
    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(24)) >> 18];
    s[ 4] = base64[(v[0] & Mask(26)) >> 24 |
		   (v[1] & Mask( 4)) <<  2];
    s[ 5] = base64[(v[1] & Mask(10)) >>  4];
    s[ 6] = base64[(v[1] & Mask(16)) >> 10];
    s[ 7] = base64[(v[1] & Mask(22)) >> 16];
    s[ 8] = base64[(v[1] & Mask(26)) >> 22 |
		   (v[2] & Mask( 2)) <<  4];
    s[ 9] = base64[(v[2] & Mask( 8)) >>  2];
    s[10] = base64[(v[2] & Mask(14)) >>  8];
    s[11] = base64[(v[2] & Mask(20)) >> 14];
    s[12] = base64[(v[2] & Mask(26)) >> 20];
    (void) e;
}

// Assembly:
movl (%rdi), %ecx
andl $0x3f, %ecx
leaq 0x14c3(%rip), %rax      # 0x9010
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
shrl $0x12, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x3(%rsi)
movzbl 0x3(%rdi), %ecx
andl $0x3, %ecx
movl 0x4(%rdi), %edx
andl $0xf, %edx
leaq (%rcx,%rdx,4), %rcx
movb (%rax,%rcx), %cl
movb %cl, 0x4(%rsi)
movl 0x4(%rdi), %ecx
shrl $0x4, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x5(%rsi)
movl 0x4(%rdi), %ecx
shrl $0xa, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x6(%rsi)
movzwl 0x6(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x7(%rsi)
movl 0x4(%rdi), %ecx
movl 0x8(%rdi), %edx
shrl $0x16, %ecx
andl $0xf, %ecx
shll $0x4, %edx
andl $0x30, %edx
orl %ecx, %edx
movb (%rdx,%rax), %cl
movb %cl, 0x8(%rsi)
movl 0x8(%rdi), %ecx
shrl $0x2, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x9(%rsi)
movl 0x8(%rdi), %ecx
shrl $0x8, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xa(%rsi)
movl 0x8(%rdi), %ecx
shrl $0xe, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xb(%rsi)
movl 0x8(%rdi), %ecx
shrl $0x14, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %al
movb %al, 0xc(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/svpv[P]rpmset/./base64pack.h
// Function: pack26x4c18e4
static inline void pack26x4c18e4(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(24)) >> 18];
    s[ 4] = base64[(v[0] & Mask(26)) >> 24 |
		   (v[1] & Mask( 4)) <<  2];
    s[ 5] = base64[(v[1] & Mask(10)) >>  4];
    s[ 6] = base64[(v[1] & Mask(16)) >> 10];
    s[ 7] = base64[(v[1] & Mask(22)) >> 16];
    s[ 8] = base64[(v[1] & Mask(26)) >> 22 |
		   (v[2] & Mask( 2)) <<  4];
    s[ 9] = base64[(v[2] & Mask( 8)) >>  2];
    s[10] = base64[(v[2] & Mask(14)) >>  8];
    s[11] = base64[(v[2] & Mask(20)) >> 14];
    s[12] = base64[(v[2] & Mask(26)) >> 20];
    s[13] = base64[ v[3] & Mask( 6)];
    s[14] = base64[(v[3] & Mask(12)) >>  6];
    s[15] = base64[(v[3] & Mask(18)) >> 12];
    s[16] = base64[(v[3] & Mask(24)) >> 18];
    s[17] = base64[(v[3] & Mask(26)) >> 24 |
		   (  e  & Mask( 4)) <<  2];
}

// Assembly:
movl (%rdi), %ecx
andl $0x3f, %ecx
leaq 0x13ef(%rip), %rax      # 0x9010
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
shrl $0x12, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x3(%rsi)
movzbl 0x3(%rdi), %ecx
andl $0x3, %ecx
movl 0x4(%rdi), %r8d
andl $0xf, %r8d
leaq (%rcx,%r8,4), %rcx
movb (%rax,%rcx), %cl
movb %cl, 0x4(%rsi)
movl 0x4(%rdi), %ecx
shrl $0x4, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x5(%rsi)
movl 0x4(%rdi), %ecx
shrl $0xa, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x6(%rsi)
movzwl 0x6(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x7(%rsi)
movl 0x4(%rdi), %ecx
movl 0x8(%rdi), %r8d
shrl $0x16, %ecx
andl $0xf, %ecx
shll $0x4, %r8d
andl $0x30, %r8d
orl %ecx, %r8d
movb (%r8,%rax), %cl
movb %cl, 0x8(%rsi)
movl 0x8(%rdi), %ecx
shrl $0x2, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x9(%rsi)
movl 0x8(%rdi), %ecx
shrl $0x8, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xa(%rsi)
movl 0x8(%rdi), %ecx
shrl $0xe, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xb(%rsi)
movl 0x8(%rdi), %ecx
shrl $0x14, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xc(%rsi)
movl 0xc(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xd(%rsi)
movl 0xc(%rdi), %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xe(%rsi)
movl 0xc(%rdi), %ecx
shrl $0xc, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xf(%rsi)
movl 0xc(%rdi), %ecx
shrl $0x12, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x10(%rsi)
movzbl 0xf(%rdi), %ecx
andl $0x3, %ecx
andl $0xf, %edx
leaq (%rcx,%rdx,4), %rcx
movb (%rax,%rcx), %al
movb %al, 0x11(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/svpv[P]rpmset/./base64pack.h
// Function: pack27x3c14e3
static inline void pack27x3c14e3(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(24)) >> 18];
    s[ 4] = base64[(v[0] & Mask(27)) >> 24 | (e & 1) << 3 |
	           (v[1] & Mask( 2)) <<  4];
    s[ 5] = base64[(v[1] & Mask( 8)) >>  2];
    s[ 6] = base64[(v[1] & Mask(14)) >>  8];
    s[ 7] = base64[(v[1] & Mask(20)) >> 14];
    s[ 8] = base64[(v[1] & Mask(26)) >> 20];
    s[ 9] = base64[(v[1] & Mask(27)) >> 26 | (e & 2) |
	           (v[2] & Mask( 4)) <<  2];
    s[10] = base64[(v[2] & Mask(10)) >>  4];
    s[11] = base64[(v[2] & Mask(16)) >> 10];
    s[12] = base64[(v[2] & Mask(22)) >> 16];
    s[13] = base64[(v[2] & Mask(27)) >> 22 | (e & 4) << 3];
}

// Assembly:
movl (%rdi), %ecx
andl $0x3f, %ecx
leaq 0x12c7(%rip), %rax      # 0x9010
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
shrl $0x12, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x3(%rsi)
movzbl 0x3(%rdi), %r8d
andl $0x7, %r8d
leal (,%rdx,8), %ecx
movl %ecx, %r9d
andl $0x8, %r9d
orl %r8d, %r9d
movl 0x4(%rdi), %r8d
shll $0x4, %r8d
andl $0x30, %r8d
orl %r9d, %r8d
movb (%r8,%rax), %r8b
movb %r8b, 0x4(%rsi)
movl 0x4(%rdi), %r8d
shrl $0x2, %r8d
andl $0x3f, %r8d
movb (%r8,%rax), %r8b
movb %r8b, 0x5(%rsi)
movl 0x4(%rdi), %r8d
shrl $0x8, %r8d
andl $0x3f, %r8d
movb (%r8,%rax), %r8b
movb %r8b, 0x6(%rsi)
movl 0x4(%rdi), %r8d
shrl $0xe, %r8d
andl $0x3f, %r8d
movb (%r8,%rax), %r8b
movb %r8b, 0x7(%rsi)
movl 0x4(%rdi), %r8d
shrl $0x14, %r8d
andl $0x3f, %r8d
movb (%r8,%rax), %r8b
movb %r8b, 0x8(%rsi)
movl 0x4(%rdi), %r8d
movl 0x8(%rdi), %r9d
shrl $0x1a, %r8d
andl $0x1, %r8d
andl $0x2, %edx
orl %r8d, %edx
andl $0xf, %r9d
leal (%rdx,%r9,4), %edx
movb (%rdx,%rax), %dl
movb %dl, 0x9(%rsi)
movl 0x8(%rdi), %edx
shrl $0x4, %edx
andl $0x3f, %edx
movb (%rdx,%rax), %dl
movb %dl, 0xa(%rsi)
movl 0x8(%rdi), %edx
shrl $0xa, %edx
andl $0x3f, %edx
movb (%rdx,%rax), %dl
movb %dl, 0xb(%rsi)
movzwl 0xa(%rdi), %edx
andl $0x3f, %edx
movb (%rdx,%rax), %dl
movb %dl, 0xc(%rsi)
movl 0x8(%rdi), %edx
shrl $0x16, %edx
andl $0x1f, %edx
andl $0x20, %ecx
orl %edx, %ecx
movb (%rcx,%rax), %al
movb %al, 0xd(%rsi)
retq