crypt/sha512.shared.v.s

   1         .file   "sha512.c"
   2 # GNU C11 (GCC) version 7.3.0 (x86_64-nyan-linux-gnu)
   3 #       compiled by GNU C version 7.3.0, GMP version 6.1.2, MPFR version 4.0.1, MPC version 1.1.0, isl version none
   4 # GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
   5 # options passed:  -I ../include
   6 # -I /root/wip/nyanglibc/builds/0/nyanglibc/build/crypt
   7 # -I /root/wip/nyanglibc/builds/0/nyanglibc/build
   8 # -I ../sysdeps/unix/sysv/linux/x86_64/64
   9 # -I ../sysdeps/unix/sysv/linux/x86_64
  10 # -I ../sysdeps/unix/sysv/linux/x86/include
  11 # -I ../sysdeps/unix/sysv/linux/x86 -I ../sysdeps/x86/nptl
  12 # -I ../sysdeps/unix/sysv/linux/wordsize-64 -I ../sysdeps/x86_64/nptl
  13 # -I ../sysdeps/unix/sysv/linux/include -I ../sysdeps/unix/sysv/linux
  14 # -I ../sysdeps/nptl -I ../sysdeps/pthread -I ../sysdeps/gnu
  15 # -I ../sysdeps/unix/inet -I ../sysdeps/unix/sysv -I ../sysdeps/unix/x86_64
  16 # -I ../sysdeps/unix -I ../sysdeps/posix -I ../sysdeps/x86_64/64
  17 # -I ../sysdeps/x86_64/fpu -I ../sysdeps/x86/fpu -I ../sysdeps/x86_64
  18 # -I ../sysdeps/x86/include -I ../sysdeps/x86
  19 # -I ../sysdeps/ieee754/float128 -I ../sysdeps/ieee754/ldbl-96/include
  20 # -I ../sysdeps/ieee754/ldbl-96 -I ../sysdeps/ieee754/dbl-64
  21 # -I ../sysdeps/ieee754/flt-32 -I ../sysdeps/wordsize-64
  22 # -I ../sysdeps/ieee754 -I ../sysdeps/generic -I .. -I ../libio -I .
  23 # -MD /run/asm/crypt/sha512.shared.v.d -MF /run/asm/crypt/sha512.os.dt -MP
  24 # -MT /run/asm/crypt/.os -D _LIBC_REENTRANT -D MODULE_NAME=libcrypt -D PIC
  25 # -D SHARED -D TOP_NAMESPACE=glibc
  26 # -include /root/wip/nyanglibc/builds/0/nyanglibc/build/libc-modules.h
  27 # -include ../include/libc-symbols.h sha512.c -mtune=generic -march=x86-64
  28 # -auxbase-strip /run/asm/crypt/sha512.shared.v.s -O2 -Wall -Wwrite-strings
  29 # -Wundef -Werror -Wstrict-prototypes -Wold-style-definition -std=gnu11
  30 # -fverbose-asm -fgnu89-inline -fmerge-all-constants -frounding-math
  31 # -fno-stack-protector -fmath-errno -fPIC -ftls-model=initial-exec
  32 # options enabled:  -fPIC -faggressive-loop-optimizations -falign-labels
  33 # -fasynchronous-unwind-tables -fauto-inc-dec -fbranch-count-reg
  34 # -fcaller-saves -fchkp-check-incomplete-type -fchkp-check-read
  35 # -fchkp-check-write -fchkp-instrument-calls -fchkp-narrow-bounds
  36 # -fchkp-optimize -fchkp-store-bounds -fchkp-use-static-bounds
  37 # -fchkp-use-static-const-bounds -fchkp-use-wrappers -fcode-hoisting
  38 # -fcombine-stack-adjustments -fcommon -fcompare-elim -fcprop-registers
  39 # -fcrossjumping -fcse-follow-jumps -fdefer-pop
  40 # -fdelete-null-pointer-checks -fdevirtualize -fdevirtualize-speculatively
  41 # -fdwarf2-cfi-asm -fearly-inlining -feliminate-unused-debug-types
  42 # -fexpensive-optimizations -fforward-propagate -ffp-int-builtin-inexact
  43 # -ffunction-cse -fgcse -fgcse-lm -fgnu-runtime -fgnu-unique
  44 # -fguess-branch-probability -fhoist-adjacent-loads -fident -fif-conversion
  45 # -fif-conversion2 -findirect-inlining -finline -finline-atomics
  46 # -finline-functions-called-once -finline-small-functions -fipa-bit-cp
  47 # -fipa-cp -fipa-icf -fipa-icf-functions -fipa-icf-variables -fipa-profile
  48 # -fipa-pure-const -fipa-ra -fipa-reference -fipa-sra -fipa-vrp
  49 # -fira-hoist-pressure -fira-share-save-slots -fira-share-spill-slots
  50 # -fisolate-erroneous-paths-dereference -fivopts -fkeep-static-consts
  51 # -fleading-underscore -flifetime-dse -flra-remat -flto-odr-type-merging
  52 # -fmath-errno -fmerge-all-constants -fmerge-debug-strings
  53 # -fmove-loop-invariants -fomit-frame-pointer -foptimize-sibling-calls
  54 # -foptimize-strlen -fpartial-inlining -fpeephole -fpeephole2 -fplt
  55 # -fprefetch-loop-arrays -free -freg-struct-return -freorder-blocks
  56 # -freorder-functions -frerun-cse-after-loop -frounding-math
  57 # -fsched-critical-path-heuristic -fsched-dep-count-heuristic
  58 # -fsched-group-heuristic -fsched-interblock -fsched-last-insn-heuristic
  59 # -fsched-rank-heuristic -fsched-spec -fsched-spec-insn-heuristic
  60 # -fsched-stalled-insns-dep -fschedule-fusion -fschedule-insns2
  61 # -fsemantic-interposition -fshow-column -fshrink-wrap
  62 # -fshrink-wrap-separate -fsigned-zeros -fsplit-ivs-in-unroller
  63 # -fsplit-wide-types -fssa-backprop -fssa-phiopt -fstdarg-opt
  64 # -fstore-merging -fstrict-aliasing -fstrict-overflow
  65 # -fstrict-volatile-bitfields -fsync-libcalls -fthread-jumps
  66 # -ftoplevel-reorder -ftrapping-math -ftree-bit-ccp -ftree-builtin-call-dce
  67 # -ftree-ccp -ftree-ch -ftree-coalesce-vars -ftree-copy-prop -ftree-cselim
  68 # -ftree-dce -ftree-dominator-opts -ftree-dse -ftree-forwprop -ftree-fre
  69 # -ftree-loop-if-convert -ftree-loop-im -ftree-loop-ivcanon
  70 # -ftree-loop-optimize -ftree-parallelize-loops= -ftree-phiprop -ftree-pre
  71 # -ftree-pta -ftree-reassoc -ftree-scev-cprop -ftree-sink -ftree-slsr
  72 # -ftree-sra -ftree-switch-conversion -ftree-tail-merge -ftree-ter
  73 # -ftree-vrp -funit-at-a-time -funwind-tables -fverbose-asm
  74 # -fzero-initialized-in-bss -m128bit-long-double -m64 -m80387
  75 # -malign-stringops -mavx256-split-unaligned-load
  76 # -mavx256-split-unaligned-store -mfancy-math-387 -mfp-ret-in-387 -mfxsr
  77 # -mglibc -mieee-fp -mlong-double-80 -mmmx -mno-sse4 -mpush-args -mred-zone
  78 # -msse -msse2 -mstv -mtls-direct-seg-refs -mvzeroupper
  79
  80         .text
  81         .p2align 4,,15
  82         .globl  __sha512_init_ctx
  83         .type   __sha512_init_ctx, @function
  84 __sha512_init_ctx:
  85 .LFB32:
  86         .cfi_startproc
  87 # sha512.c:112:   ctx->H[0] = UINT64_C (0x6a09e667f3bcc908);
  88         movabsq $7640891576956012808, %rax      #, tmp96
  89 # sha512.c:121:   ctx->total[0] = ctx->total[1] = 0;
  90         movq    $0, 72(%rdi)    #, ctx_2(D)->D.4694.total
  91         movq    $0, 64(%rdi)    #, ctx_2(D)->D.4694.total
  92 # sha512.c:112:   ctx->H[0] = UINT64_C (0x6a09e667f3bcc908);
  93         movq    %rax, (%rdi)    # tmp96, ctx_2(D)->H
  94 # sha512.c:113:   ctx->H[1] = UINT64_C (0xbb67ae8584caa73b);
  95         movabsq $-4942790177534073029, %rax     #, tmp97
  96 # sha512.c:122:   ctx->buflen = 0;
  97         movq    $0, 80(%rdi)    #, ctx_2(D)->buflen
  98 # sha512.c:113:   ctx->H[1] = UINT64_C (0xbb67ae8584caa73b);
  99         movq    %rax, 8(%rdi)   # tmp97, ctx_2(D)->H
 100 # sha512.c:114:   ctx->H[2] = UINT64_C (0x3c6ef372fe94f82b);
 101         movabsq $4354685564936845355, %rax      #, tmp98
 102         movq    %rax, 16(%rdi)  # tmp98, ctx_2(D)->H
 103 # sha512.c:115:   ctx->H[3] = UINT64_C (0xa54ff53a5f1d36f1);
 104         movabsq $-6534734903238641935, %rax     #, tmp99
 105         movq    %rax, 24(%rdi)  # tmp99, ctx_2(D)->H
 106 # sha512.c:116:   ctx->H[4] = UINT64_C (0x510e527fade682d1);
 107         movabsq $5840696475078001361, %rax      #, tmp100
 108         movq    %rax, 32(%rdi)  # tmp100, ctx_2(D)->H
 109 # sha512.c:117:   ctx->H[5] = UINT64_C (0x9b05688c2b3e6c1f);
 110         movabsq $-7276294671716946913, %rax     #, tmp101
 111         movq    %rax, 40(%rdi)  # tmp101, ctx_2(D)->H
 112 # sha512.c:118:   ctx->H[6] = UINT64_C (0x1f83d9abfb41bd6b);
 113         movabsq $2270897969802886507, %rax      #, tmp102
 114         movq    %rax, 48(%rdi)  # tmp102, ctx_2(D)->H
 115 # sha512.c:119:   ctx->H[7] = UINT64_C (0x5be0cd19137e2179);
 116         movabsq $6620516959819538809, %rax      #, tmp103
 117         movq    %rax, 56(%rdi)  # tmp103, ctx_2(D)->H
 118 # sha512.c:123: }
 119         ret
 120         .cfi_endproc
 121 .LFE32:
 122         .size   __sha512_init_ctx, .-__sha512_init_ctx
 123         .p2align 4,,15
 124         .globl  __sha512_process_block
 125         .type   __sha512_process_block, @function
 126 __sha512_process_block:
 127 .LFB35:
 128         .cfi_startproc
 129         pushq   %r15    #
 130         .cfi_def_cfa_offset 16
 131         .cfi_offset 15, -16
 132         pushq   %r14    #
 133         .cfi_def_cfa_offset 24
 134         .cfi_offset 14, -24
 135         pushq   %r13    #
 136         .cfi_def_cfa_offset 32
 137         .cfi_offset 13, -32
 138         pushq   %r12    #
 139         .cfi_def_cfa_offset 40
 140         .cfi_offset 12, -40
 141         pushq   %rbp    #
 142         .cfi_def_cfa_offset 48
 143         .cfi_offset 6, -48
 144         pushq   %rbx    #
 145         .cfi_def_cfa_offset 56
 146         .cfi_offset 3, -56
 147         movq    %rdx, %rbx      # ctx, ctx
 148         subq    $624, %rsp      #,
 149         .cfi_def_cfa_offset 680
 150 # ./sha512-block.c:10:   uint64_t a = ctx->H[0];
 151         movq    (%rdx), %rax    # ctx_81(D)->H, a
 152 # ./sha512-block.c:7: {
 153         movq    %rdi, -56(%rsp) # buffer, %sfp
 154 # ./sha512-block.c:9:   size_t nwords = len / sizeof (uint64_t);
 155         movq    %rsi, %rdi      # len, nwords
 156 # ./sha512-block.c:7: {
 157         movq    %rdx, -32(%rsp) # ctx, %sfp
 158 # ./sha512-block.c:9:   size_t nwords = len / sizeof (uint64_t);
 159         shrq    $3, %rdi        #, nwords
 160 # ./sha512-block.c:10:   uint64_t a = ctx->H[0];
 161         movq    %rax, -96(%rsp) # a, %sfp
 162 # ./sha512-block.c:11:   uint64_t b = ctx->H[1];
 163         movq    8(%rdx), %rax   # ctx_81(D)->H, b
 164 # ./sha512-block.c:9:   size_t nwords = len / sizeof (uint64_t);
 165         movq    %rdi, -48(%rsp) # nwords, %sfp
 166 # ./sha512-block.c:11:   uint64_t b = ctx->H[1];
 167         movq    %rax, -88(%rsp) # b, %sfp
 168 # ./sha512-block.c:12:   uint64_t c = ctx->H[2];
 169         movq    16(%rdx), %rax  # ctx_81(D)->H, c
 170         movq    %rax, -80(%rsp) # c, %sfp
 171 # ./sha512-block.c:13:   uint64_t d = ctx->H[3];
 172         movq    24(%rdx), %rax  # ctx_81(D)->H, d
 173         movq    %rax, -104(%rsp)        # d, %sfp
 174 # ./sha512-block.c:14:   uint64_t e = ctx->H[4];
 175         movq    32(%rdx), %rax  # ctx_81(D)->H, e
 176         movq    %rax, -72(%rsp) # e, %sfp
 177 # ./sha512-block.c:15:   uint64_t f = ctx->H[5];
 178         movq    40(%rdx), %rax  # ctx_81(D)->H, f
 179         movq    %rax, -112(%rsp)        # f, %sfp
 180 # ./sha512-block.c:16:   uint64_t g = ctx->H[6];
 181         movq    48(%rdx), %rax  # ctx_81(D)->H, g
 182         movq    %rax, -64(%rsp) # g, %sfp
 183 # ./sha512-block.c:17:   uint64_t h = ctx->H[7];
 184         movq    56(%rdx), %rax  # ctx_81(D)->H, h
 185 # ./sha512-block.c:23:   ctx->total128 += len;
 186         xorl    %edx, %edx      # len
 187         addq    %rsi, 64(%rbx)  # len, ctx_81(D)->D.4694.total128
 188         adcq    %rdx, 72(%rbx)  # len, ctx_81(D)->D.4694.total128
 189 # ./sha512-block.c:33:   while (nwords > 0)
 190         testq   %rdi, %rdi      # nwords
 191 # ./sha512-block.c:17:   uint64_t h = ctx->H[7];
 192         movq    %rax, -120(%rsp)        # h, %sfp
 193 # ./sha512-block.c:33:   while (nwords > 0)
 194         je      .L4     #,
 195         leaq    -24(%rsp), %r14 #, tmp243
 196         leaq    K(%rip), %r15   #, tmp244
 197         leaq    512(%r14), %rax #, _215
 198         movq    %rax, -40(%rsp) # _215, %sfp
 199         .p2align 4,,10
 200         .p2align 3
 201 .L9:
 202 # ./sha512-block.c:7: {
 203         movq    -56(%rsp), %rcx # %sfp, buffer
 204         xorl    %eax, %eax      # ivtmp.42
 205         .p2align 4,,10
 206         .p2align 3
 207 .L5:
 208 # ../bits/byteswap.h:73:   return __builtin_bswap64 (__bsx);
 209         movq    (%rcx,%rax), %rdx       # MEM[base: words_140, index: ivtmp.42_214, offset: 0B], MEM[base: words_140, index: ivtmp.42_214, offset: 0B]
 210         bswap   %rdx    # _130
 211 # ./sha512-block.c:60:    W[t] = SWAP (*words);
 212         movq    %rdx, (%r14,%rax)       # _130, MEM[symbol: W, index: ivtmp.42_214, offset: 0B]
 213         addq    $8, %rax        #, ivtmp.42
 214 # ./sha512-block.c:58:       for (unsigned int t = 0; t < 16; ++t)
 215         cmpq    $128, %rax      #, ivtmp.42
 216         jne     .L5     #,
 217         subq    $-128, -56(%rsp)        #, %sfp
 218         movq    -40(%rsp), %rdi # %sfp, _215
 219         movq    %r14, %rsi      # tmp243, ivtmp.38
 220         .p2align 4,,10
 221         .p2align 3
 222 .L6:
 223 # ./sha512-block.c:64:  W[t] = R1 (W[t - 2]) + W[t - 7] + R0 (W[t - 15]) + W[t - 16];
 224         movq    112(%rsi), %rax # MEM[base: _218, offset: 112B], _6
 225         movq    8(%rsi), %rcx   # MEM[base: _218, offset: 8B], _19
 226         addq    $8, %rsi        #, ivtmp.38
 227         movq    %rax, %rdx      # _6, tmp204
 228         movq    %rax, %r8       # _6, tmp205
 229         shrq    $6, %rax        #, tmp207
 230         rolq    $3, %r8 #, tmp205
 231         rorq    $19, %rdx       #, tmp204
 232         xorq    %r8, %rdx       # tmp205, tmp206
 233         movq    %rcx, %r8       # _19, tmp214
 234         xorq    %rax, %rdx      # tmp207, tmp208
 235         movq    -8(%rsi), %rax  # MEM[base: _218, offset: 0B], MEM[base: _218, offset: 0B]
 236         addq    64(%rsi), %rax  # MEM[base: _218, offset: 72B], tmp209
 237         rorq    $8, %r8 #, tmp214
 238         addq    %rax, %rdx      # tmp209, tmp212
 239         movq    %rcx, %rax      # _19, tmp213
 240         shrq    $7, %rcx        #, tmp216
 241         rorq    %rax    # tmp213
 242         xorq    %r8, %rax       # tmp214, tmp215
 243         xorq    %rcx, %rax      # tmp216, tmp217
 244         addq    %rdx, %rax      # tmp212, tmp218
 245         movq    %rax, 120(%rsi) # tmp218, MEM[base: _218, offset: 128B]
 246 # ./sha512-block.c:63:       for (unsigned int t = 16; t < 80; ++t)
 247         cmpq    %rsi, %rdi      # ivtmp.38, _215
 248         jne     .L6     #,
 249         movq    -120(%rsp), %rax        # %sfp, h
 250         movq    -64(%rsp), %rbx # %sfp, g
 251         xorl    %r9d, %r9d      # ivtmp.28
 252         movq    -112(%rsp), %rbp        # %sfp, f
 253         movq    -72(%rsp), %rdi # %sfp, e
 254         movabsq $4794697086780616226, %r12      #, pretmp_256
 255         movq    -104(%rsp), %r13        # %sfp, d
 256         movq    -80(%rsp), %r10 # %sfp, c
 257         movq    -88(%rsp), %r11 # %sfp, b
 258         movq    -96(%rsp), %r8  # %sfp, a
 259         movq    %rax, %rsi      # h, h
 260         jmp     .L8     #
 261         .p2align 4,,10
 262         .p2align 3
 263 .L17:
 264         movq    (%r15,%r9), %r12        # MEM[symbol: K, index: ivtmp.28_225, offset: 0B], pretmp_256
 265         movq    %r10, %r13      # c, d
 266         movq    %rbx, %rsi      # g, h
 267 # ./sha512-block.c:74:    e = d + T1;
 268         movq    %r11, %r10      # b, c
 269         movq    %rbp, %rbx      # f, g
 270         movq    %r8, %r11       # a, b
 271         movq    %rdi, %rbp      # e, f
 272 # ./sha512-block.c:78:    a = T1 + T2;
 273         movq    %rax, %r8       # a, a
 274 # ./sha512-block.c:74:    e = d + T1;
 275         movq    %rcx, %rdi      # e, e
 276 .L8:
 277 # ./sha512-block.c:69:    uint64_t T1 = h + S1 (e) + Ch (e, f, g) + K[t] + W[t];
 278         movq    %rdi, %rax      # e, tmp219
 279         movq    %rdi, %rdx      # e, tmp220
 280         movq    %rdi, %rcx      # e, tmp226
 281         rorq    $18, %rdx       #, tmp220
 282         rorq    $14, %rax       #, tmp219
 283         andq    %rbp, %rcx      # f, tmp226
 284         xorq    %rdx, %rax      # tmp220, tmp221
 285         movq    %rdi, %rdx      # e, tmp222
 286         rolq    $23, %rdx       #, tmp222
 287         xorq    %rax, %rdx      # tmp221, tmp223
 288         movq    %rdi, %rax      # e, tmp224
 289         notq    %rax    # tmp224
 290         andq    %rbx, %rax      # g, tmp225
 291         xorq    %rcx, %rax      # tmp226, tmp227
 292 # ./sha512-block.c:70:    uint64_t T2 = S0 (a) + Maj (a, b, c);
 293         movq    %r8, %rcx       # a, tmp234
 294 # ./sha512-block.c:69:    uint64_t T1 = h + S1 (e) + Ch (e, f, g) + K[t] + W[t];
 295         addq    %rdx, %rax      # tmp223, tmp228
 296 # ./sha512-block.c:70:    uint64_t T2 = S0 (a) + Maj (a, b, c);
 297         movq    %r8, %rdx       # a, tmp233
 298 # ./sha512-block.c:69:    uint64_t T1 = h + S1 (e) + Ch (e, f, g) + K[t] + W[t];
 299         addq    (%r14,%r9), %rax        # MEM[symbol: W, index: ivtmp.28_226, offset: 0B], tmp230
 300 # ./sha512-block.c:70:    uint64_t T2 = S0 (a) + Maj (a, b, c);
 301         rolq    $30, %rcx       #, tmp234
 302         rorq    $28, %rdx       #, tmp233
 303         addq    $8, %r9 #, ivtmp.28
 304         xorq    %rcx, %rdx      # tmp234, tmp235
 305         movq    %r8, %rcx       # a, tmp236
 306         rolq    $25, %rcx       #, tmp236
 307         xorq    %rdx, %rcx      # tmp235, tmp237
 308         movq    %r11, %rdx      # b, tmp238
 309 # ./sha512-block.c:69:    uint64_t T1 = h + S1 (e) + Ch (e, f, g) + K[t] + W[t];
 310         addq    %rsi, %rax      # h, tmp232
 311 # ./sha512-block.c:70:    uint64_t T2 = S0 (a) + Maj (a, b, c);
 312         xorq    %r10, %rdx      # c, tmp238
 313         movq    %r11, %rsi      # b, tmp240
 314 # ./sha512-block.c:69:    uint64_t T1 = h + S1 (e) + Ch (e, f, g) + K[t] + W[t];
 315         addq    %r12, %rax      # pretmp_256, T1
 316 # ./sha512-block.c:70:    uint64_t T2 = S0 (a) + Maj (a, b, c);
 317         andq    %r8, %rdx       # a, tmp239
 318         andq    %r10, %rsi      # c, tmp240
 319         xorq    %rsi, %rdx      # tmp240, tmp241
 320         addq    %rcx, %rdx      # tmp237, T2
 321 # ./sha512-block.c:74:    e = d + T1;
 322         leaq    (%rax,%r13), %rcx       #, e
 323 # ./sha512-block.c:78:    a = T1 + T2;
 324         addq    %rdx, %rax      # T2, a
 325 # ./sha512-block.c:67:       for (unsigned int t = 0; t < 80; ++t)
 326         cmpq    $640, %r9       #, ivtmp.28
 327         jne     .L17    #,
 328 # ./sha512-block.c:83:       a += a_save;
 329         addq    %rax, -96(%rsp) # a, %sfp
 330 # ./sha512-block.c:84:       b += b_save;
 331         addq    %r8, -88(%rsp)  # a, %sfp
 332 # ./sha512-block.c:85:       c += c_save;
 333         addq    %r11, -80(%rsp) # b, %sfp
 334 # ./sha512-block.c:86:       d += d_save;
 335         addq    %r10, -104(%rsp)        # c, %sfp
 336 # ./sha512-block.c:87:       e += e_save;
 337         addq    %rcx, -72(%rsp) # e, %sfp
 338 # ./sha512-block.c:88:       f += f_save;
 339         addq    %rdi, -112(%rsp)        # e, %sfp
 340 # ./sha512-block.c:89:       g += g_save;
 341         addq    %rbp, -64(%rsp) # f, %sfp
 342 # ./sha512-block.c:90:       h += h_save;
 343         addq    %rbx, -120(%rsp)        # g, %sfp
 344 # ./sha512-block.c:33:   while (nwords > 0)
 345         subq    $16, -48(%rsp)  #, %sfp
 346         jne     .L9     #,
 347 .L4:
 348 # ./sha512-block.c:97:   ctx->H[0] = a;
 349         movq    -32(%rsp), %rax # %sfp, ctx
 350         movq    -96(%rsp), %rbx # %sfp, a
 351         movq    %rbx, (%rax)    # a, ctx_81(D)->H
 352 # ./sha512-block.c:98:   ctx->H[1] = b;
 353         movq    -88(%rsp), %rbx # %sfp, b
 354         movq    %rbx, 8(%rax)   # b, ctx_81(D)->H
 355 # ./sha512-block.c:99:   ctx->H[2] = c;
 356         movq    -80(%rsp), %rbx # %sfp, c
 357         movq    %rbx, 16(%rax)  # c, ctx_81(D)->H
 358 # ./sha512-block.c:100:   ctx->H[3] = d;
 359         movq    -104(%rsp), %rbx        # %sfp, d
 360         movq    %rbx, 24(%rax)  # d, ctx_81(D)->H
 361 # ./sha512-block.c:101:   ctx->H[4] = e;
 362         movq    -72(%rsp), %rbx # %sfp, e
 363         movq    %rbx, 32(%rax)  # e, ctx_81(D)->H
 364 # ./sha512-block.c:102:   ctx->H[5] = f;
 365         movq    -112(%rsp), %rbx        # %sfp, f
 366         movq    %rbx, 40(%rax)  # f, ctx_81(D)->H
 367 # ./sha512-block.c:103:   ctx->H[6] = g;
 368         movq    -64(%rsp), %rbx # %sfp, g
 369         movq    %rbx, 48(%rax)  # g, ctx_81(D)->H
 370 # ./sha512-block.c:104:   ctx->H[7] = h;
 371         movq    -120(%rsp), %rbx        # %sfp, h
 372         movq    %rbx, 56(%rax)  # h, ctx_81(D)->H
 373 # ./sha512-block.c:105: }
 374         addq    $624, %rsp      #,
 375         .cfi_def_cfa_offset 56
 376         popq    %rbx    #
 377         .cfi_def_cfa_offset 48
 378         popq    %rbp    #
 379         .cfi_def_cfa_offset 40
 380         popq    %r12    #
 381         .cfi_def_cfa_offset 32
 382         popq    %r13    #
 383         .cfi_def_cfa_offset 24
 384         popq    %r14    #
 385         .cfi_def_cfa_offset 16
 386         popq    %r15    #
 387         .cfi_def_cfa_offset 8
 388         ret
 389         .cfi_endproc
 390 .LFE35:
 391         .size   __sha512_process_block, .-__sha512_process_block
 392         .p2align 4,,15
 393         .globl  __sha512_finish_ctx
 394         .type   __sha512_finish_ctx, @function
 395 __sha512_finish_ctx:
 396 .LFB33:
 397         .cfi_startproc
 398         pushq   %r14    #
 399         .cfi_def_cfa_offset 16
 400         .cfi_offset 14, -16
 401         pushq   %r13    #
 402         .cfi_def_cfa_offset 24
 403         .cfi_offset 13, -24
 404         pushq   %r12    #
 405         .cfi_def_cfa_offset 32
 406         .cfi_offset 12, -32
 407         pushq   %rbp    #
 408         .cfi_def_cfa_offset 40
 409         .cfi_offset 6, -40
 410         movq    %rsi, %rbp      # resbuf, resbuf
 411         pushq   %rbx    #
 412         .cfi_def_cfa_offset 48
 413         .cfi_offset 3, -48
 414 # sha512.c:135:   uint64_t bytes = ctx->buflen;
 415         movq    80(%rdi), %rax  # ctx_25(D)->buflen, bytes
 416 # sha512.c:133: {
 417         movq    %rdi, %rbx      # ctx, ctx
 418 # sha512.c:140:   ctx->total128 += bytes;
 419         xorl    %edi, %edi      # bytes
 420         addq    %rax, 64(%rbx)  # bytes, ctx_25(D)->D.4694.total128
 421         adcq    %rdi, 72(%rbx)  # bytes, ctx_25(D)->D.4694.total128
 422 # sha512.c:147:   pad = bytes >= 112 ? 128 + 112 - bytes : 112 - bytes;
 423         cmpq    $111, %rax      #, bytes
 424         jbe     .L19    #,
 425 # sha512.c:147:   pad = bytes >= 112 ? 128 + 112 - bytes : 112 - bytes;
 426         movl    $240, %edx      #, tmp117
 427         movl    $256, %r12d     #, prephitmp_49
 428         movl    $30, %r13d      #, prephitmp_48
 429         subq    %rax, %rdx      # bytes, iftmp.0_22
 430         movl    $31, %r14d      #, prephitmp_41
 431 .L20:
 432 # sha512.c:148:   memcpy (&ctx->buffer[bytes], fillbuf, pad);
 433         leaq    88(%rbx,%rax), %rdi     #, tmp120
 434         leaq    fillbuf(%rip), %rsi     #,
 435         call    memcpy@PLT      #
 436 # sha512.c:151:   ctx->buffer64[(bytes + pad + 8) / 8] = SWAP (ctx->total[TOTAL128_low] << 3);
 437         movq    64(%rbx), %rdx  # ctx_25(D)->D.4694.total, _5
 438 # sha512.c:156:   __sha512_process_block (ctx->buffer, bytes + pad + 16, ctx);
 439         leaq    88(%rbx), %rdi  #, tmp134
 440         movq    %r12, %rsi      # prephitmp_49,
 441 # sha512.c:151:   ctx->buffer64[(bytes + pad + 8) / 8] = SWAP (ctx->total[TOTAL128_low] << 3);
 442         leaq    0(,%rdx,8), %rax        #, tmp127
 443 # sha512.c:152:   ctx->buffer64[(bytes + pad) / 8] = SWAP ((ctx->total[TOTAL128_high] << 3)
 444         shrq    $61, %rdx       #, tmp131
 445 # ../bits/byteswap.h:73:   return __builtin_bswap64 (__bsx);
 446         bswap   %rax    # _33
 447 # sha512.c:151:   ctx->buffer64[(bytes + pad + 8) / 8] = SWAP (ctx->total[TOTAL128_low] << 3);
 448         movq    %rax, 88(%rbx,%r14,8)   # _33, ctx_25(D)->D.4699.buffer64
 449 # sha512.c:152:   ctx->buffer64[(bytes + pad) / 8] = SWAP ((ctx->total[TOTAL128_high] << 3)
 450         movq    72(%rbx), %rax  # ctx_25(D)->D.4694.total, tmp137
 451         salq    $3, %rax        #, tmp129
 452         orq     %rdx, %rax      # tmp131, tmp132
 453 # sha512.c:156:   __sha512_process_block (ctx->buffer, bytes + pad + 16, ctx);
 454         movq    %rbx, %rdx      # ctx,
 455 # ../bits/byteswap.h:73:   return __builtin_bswap64 (__bsx);
 456         bswap   %rax    # _37
 457 # sha512.c:152:   ctx->buffer64[(bytes + pad) / 8] = SWAP ((ctx->total[TOTAL128_high] << 3)
 458         movq    %rax, 88(%rbx,%r13,8)   # _37, ctx_25(D)->D.4699.buffer64
 459 # sha512.c:156:   __sha512_process_block (ctx->buffer, bytes + pad + 16, ctx);
 460         call    __sha512_process_block@PLT      #
 461         xorl    %eax, %eax      # ivtmp.67
 462         .p2align 4,,10
 463         .p2align 3
 464 .L21:
 465 # ../bits/byteswap.h:73:   return __builtin_bswap64 (__bsx);
 466         movq    (%rbx,%rax), %rdx       # MEM[base: ctx_25(D), index: ivtmp.67_40, offset: 0B], MEM[base: ctx_25(D), index: ivtmp.67_40, offset: 0B]
 467         bswap   %rdx    # _31
 468 # sha512.c:160:     ((uint64_t *) resbuf)[i] = SWAP (ctx->H[i]);
 469         movq    %rdx, 0(%rbp,%rax)      # _31, MEM[base: resbuf_36(D), index: ivtmp.67_40, offset: 0B]
 470         addq    $8, %rax        #, ivtmp.67
 471 # sha512.c:159:   for (unsigned int i = 0; i < 8; ++i)
 472         cmpq    $64, %rax       #, ivtmp.67
 473         jne     .L21    #,
 474 # sha512.c:163: }
 475         popq    %rbx    #
 476         .cfi_remember_state
 477         .cfi_def_cfa_offset 40
 478         movq    %rbp, %rax      # resbuf,
 479         popq    %rbp    #
 480         .cfi_def_cfa_offset 32
 481         popq    %r12    #
 482         .cfi_def_cfa_offset 24
 483         popq    %r13    #
 484         .cfi_def_cfa_offset 16
 485         popq    %r14    #
 486         .cfi_def_cfa_offset 8
 487         ret
 488         .p2align 4,,10
 489         .p2align 3
 490 .L19:
 491         .cfi_restore_state
 492 # sha512.c:147:   pad = bytes >= 112 ? 128 + 112 - bytes : 112 - bytes;
 493         movl    $112, %edx      #, tmp118
 494         movl    $128, %r12d     #, prephitmp_49
 495         movl    $14, %r13d      #, prephitmp_48
 496         subq    %rax, %rdx      # bytes, iftmp.0_22
 497         movl    $15, %r14d      #, prephitmp_41
 498         jmp     .L20    #
 499         .cfi_endproc
 500 .LFE33:
 501         .size   __sha512_finish_ctx, .-__sha512_finish_ctx
 502         .p2align 4,,15
 503         .globl  __sha512_process_bytes
 504         .type   __sha512_process_bytes, @function
 505 __sha512_process_bytes:
 506 .LFB34:
 507         .cfi_startproc
 508         pushq   %r15    #
 509         .cfi_def_cfa_offset 16
 510         .cfi_offset 15, -16
 511         pushq   %r14    #
 512         .cfi_def_cfa_offset 24
 513         .cfi_offset 14, -24
 514         pushq   %r13    #
 515         .cfi_def_cfa_offset 32
 516         .cfi_offset 13, -32
 517         pushq   %r12    #
 518         .cfi_def_cfa_offset 40
 519         .cfi_offset 12, -40
 520         movq    %rdi, %r12      # buffer, buffer
 521         pushq   %rbp    #
 522         .cfi_def_cfa_offset 48
 523         .cfi_offset 6, -48
 524         pushq   %rbx    #
 525         .cfi_def_cfa_offset 56
 526         .cfi_offset 3, -56
 527         movq    %rdx, %rbp      # ctx, ctx
 528         movq    %rsi, %rbx      # len, len
 529         subq    $8, %rsp        #,
 530         .cfi_def_cfa_offset 64
 531 # sha512.c:171:   if (ctx->buflen != 0)
 532         movq    80(%rdx), %r14  # ctx_28(D)->buflen, _1
 533         testq   %r14, %r14      # _1
 534         jne     .L54    #,
 535 .L25:
 536 # sha512.c:194:   if (len >= 128)
 537         cmpq    $127, %rbx      #, len
 538         ja      .L55    #,
 539 .L31:
 540 # sha512.c:222:   if (len > 0)
 541         testq   %rbx, %rbx      # len
 542         jne     .L56    #,
 543 # sha512.c:236: }
 544         addq    $8, %rsp        #,
 545         .cfi_remember_state
 546         .cfi_def_cfa_offset 56
 547         popq    %rbx    #
 548         .cfi_def_cfa_offset 48
 549         popq    %rbp    #
 550         .cfi_def_cfa_offset 40
 551         popq    %r12    #
 552         .cfi_def_cfa_offset 32
 553         popq    %r13    #
 554         .cfi_def_cfa_offset 24
 555         popq    %r14    #
 556         .cfi_def_cfa_offset 16
 557         popq    %r15    #
 558         .cfi_def_cfa_offset 8
 559         ret
 560         .p2align 4,,10
 561         .p2align 3
 562 .L56:
 563         .cfi_restore_state
 564 # sha512.c:224:       size_t left_over = ctx->buflen;
 565         movq    80(%rbp), %r8   # ctx_28(D)->buflen, left_over
 566 # sha512.c:226:       memcpy (&ctx->buffer[left_over], buffer, len);
 567         cmpl    $8, %ebx        #, len
 568         leaq    88(%rbp,%r8), %rdx      #, tmp161
 569         jnb     .L33    #,
 570         testb   $4, %bl #, len
 571         jne     .L57    #,
 572         testl   %ebx, %ebx      # len
 573         je      .L34    #,
 574         movzbl  (%r12), %eax    #* buffer, tmp174
 575         testb   $2, %bl #, len
 576         movb    %al, (%rdx)     # tmp174,
 577         jne     .L58    #,
 578 .L34:
 579 # sha512.c:227:       left_over += len;
 580         addq    %r8, %rbx       # left_over, left_over
 581 # sha512.c:228:       if (left_over >= 128)
 582         cmpq    $127, %rbx      #, left_over
 583         ja      .L59    #,
 584 .L37:
 585 # sha512.c:234:       ctx->buflen = left_over;
 586         movq    %rbx, 80(%rbp)  # left_over, ctx_28(D)->buflen
 587 # sha512.c:236: }
 588         addq    $8, %rsp        #,
 589         .cfi_remember_state
 590         .cfi_def_cfa_offset 56
 591         popq    %rbx    #
 592         .cfi_def_cfa_offset 48
 593         popq    %rbp    #
 594         .cfi_def_cfa_offset 40
 595         popq    %r12    #
 596         .cfi_def_cfa_offset 32
 597         popq    %r13    #
 598         .cfi_def_cfa_offset 24
 599         popq    %r14    #
 600         .cfi_def_cfa_offset 16
 601         popq    %r15    #
 602         .cfi_def_cfa_offset 8
 603         ret
 604         .p2align 4,,10
 605         .p2align 3
 606 .L55:
 607         .cfi_restore_state
 608 # sha512.c:215:           __sha512_process_block (buffer, len & ~127, ctx);
 609         movq    %rbx, %r13      # len, _13
 610         movq    %r12, %rdi      # buffer,
 611         movq    %rbp, %rdx      # ctx,
 612         andq    $-128, %r13     #, _13
 613 # sha512.c:217:           len &= 127;
 614         andl    $127, %ebx      #, len
 615 # sha512.c:215:           __sha512_process_block (buffer, len & ~127, ctx);
 616         movq    %r13, %rsi      # _13,
 617 # sha512.c:216:           buffer = (const char *) buffer + (len & ~127);
 618         addq    %r13, %r12      # _13, buffer
 619 # sha512.c:215:           __sha512_process_block (buffer, len & ~127, ctx);
 620         call    __sha512_process_block@PLT      #
 621         jmp     .L31    #
 622         .p2align 4,,10
 623         .p2align 3
 624 .L54:
 625 # sha512.c:174:       size_t add = 256 - left_over > len ? len : 256 - left_over;
 626         movl    $256, %r13d     #, tmp113
 627 # sha512.c:176:       memcpy (&ctx->buffer[left_over], buffer, add);
 628         leaq    88(%rdx,%r14), %rdi     #, tmp115
 629 # sha512.c:174:       size_t add = 256 - left_over > len ? len : 256 - left_over;
 630         subq    %r14, %r13      # _1, tmp112
 631         cmpq    %rsi, %r13      # len, tmp112
 632         cmova   %rsi, %r13      # tmp112,, len, add
 633 # sha512.c:176:       memcpy (&ctx->buffer[left_over], buffer, add);
 634         movq    %r12, %rsi      # buffer,
 635         movq    %r13, %rdx      # add,
 636         call    memcpy@PLT      #
 637 # sha512.c:177:       ctx->buflen += add;
 638         movq    80(%rbp), %rsi  # ctx_28(D)->buflen, _5
 639         addq    %r13, %rsi      # add, _5
 640 # sha512.c:179:       if (ctx->buflen > 128)
 641         cmpq    $128, %rsi      #, _5
 642 # sha512.c:177:       ctx->buflen += add;
 643         movq    %rsi, 80(%rbp)  # _5, ctx_28(D)->buflen
 644 # sha512.c:179:       if (ctx->buflen > 128)
 645         ja      .L60    #,
 646 .L26:
 647 # sha512.c:189:       buffer = (const char *) buffer + add;
 648         addq    %r13, %r12      # add, buffer
 649 # sha512.c:190:       len -= add;
 650         subq    %r13, %rbx      # add, len
 651         jmp     .L25    #
 652         .p2align 4,,10
 653         .p2align 3
 654 .L33:
 655 # sha512.c:226:       memcpy (&ctx->buffer[left_over], buffer, len);
 656         movq    (%r12), %rax    #* buffer, tmp183
 657         leaq    8(%rdx), %rdi   #, tmp191
 658         movq    %r12, %rsi      # buffer, buffer
 659         andq    $-8, %rdi       #, tmp191
 660         movq    %rax, (%rdx)    # tmp183,
 661         movl    %ebx, %eax      # len, len
 662         movq    -8(%r12,%rax), %rcx     #, tmp190
 663         movq    %rcx, -8(%rdx,%rax)     # tmp190,
 664         subq    %rdi, %rdx      # tmp191, tmp163
 665         leal    (%rbx,%rdx), %ecx       #, len
 666 # sha512.c:227:       left_over += len;
 667         addq    %r8, %rbx       # left_over, left_over
 668 # sha512.c:226:       memcpy (&ctx->buffer[left_over], buffer, len);
 669         subq    %rdx, %rsi      # tmp163, buffer
 670         shrl    $3, %ecx        #,
 671 # sha512.c:228:       if (left_over >= 128)
 672         cmpq    $127, %rbx      #, left_over
 673 # sha512.c:226:       memcpy (&ctx->buffer[left_over], buffer, len);
 674         rep movsq
 675 # sha512.c:228:       if (left_over >= 128)
 676         jbe     .L37    #,
 677 .L59:
 678 # sha512.c:230:           __sha512_process_block (ctx->buffer, 128, ctx);
 679         leaq    88(%rbp), %r12  #, _15
 680         movq    %rbp, %rdx      # ctx,
 681         movl    $128, %esi      #,
 682 # sha512.c:231:           left_over -= 128;
 683         addq    $-128, %rbx     #, left_over
 684 # sha512.c:230:           __sha512_process_block (ctx->buffer, 128, ctx);
 685         movq    %r12, %rdi      # _15,
 686         call    __sha512_process_block@PLT      #
 687 # sha512.c:232:           memcpy (ctx->buffer, &ctx->buffer[128], left_over);
 688         leaq    216(%rbp), %rsi #, tmp194
 689         movq    %rbx, %rdx      # left_over,
 690         movq    %r12, %rdi      # _15,
 691         call    memcpy@PLT      #
 692         jmp     .L37    #
 693         .p2align 4,,10
 694         .p2align 3
 695 .L60:
 696 # sha512.c:181:           __sha512_process_block (ctx->buffer, ctx->buflen & ~127, ctx);
 697         leaq    88(%rbp), %r15  #, _7
 698         andq    $-128, %rsi     #, tmp122
 699         movq    %rbp, %rdx      # ctx,
 700 # sha512.c:185:           memcpy (ctx->buffer, &ctx->buffer[(left_over + add) & ~127],
 701         addq    %r13, %r14      # add, tmp124
 702 # sha512.c:181:           __sha512_process_block (ctx->buffer, ctx->buflen & ~127, ctx);
 703         movq    %r15, %rdi      # _7,
 704 # sha512.c:185:           memcpy (ctx->buffer, &ctx->buffer[(left_over + add) & ~127],
 705         andq    $-128, %r14     #, tmp125
 706 # sha512.c:181:           __sha512_process_block (ctx->buffer, ctx->buflen & ~127, ctx);
 707         call    __sha512_process_block@PLT      #
 708 # sha512.c:183:           ctx->buflen &= 127;
 709         movq    80(%rbp), %rax  # ctx_28(D)->buflen, _9
 710 # sha512.c:185:           memcpy (ctx->buffer, &ctx->buffer[(left_over + add) & ~127],
 711         leaq    88(%rbp,%r14), %rsi     #, tmp127
 712 # sha512.c:183:           ctx->buflen &= 127;
 713         andl    $127, %eax      #, _9
 714 # sha512.c:185:           memcpy (ctx->buffer, &ctx->buffer[(left_over + add) & ~127],
 715         cmpl    $8, %eax        #, _9
 716 # sha512.c:183:           ctx->buflen &= 127;
 717         movq    %rax, 80(%rbp)  # _9, ctx_28(D)->buflen
 718 # sha512.c:185:           memcpy (ctx->buffer, &ctx->buffer[(left_over + add) & ~127],
 719         jnb     .L27    #,
 720         testb   $4, %al #, _9
 721         jne     .L61    #,
 722         testl   %eax, %eax      # _9
 723         je      .L26    #,
 724         movzbl  (%rsi), %edx    #, tmp140
 725         testb   $2, %al #, _9
 726         movb    %dl, 88(%rbp)   # tmp140,
 727         je      .L26    #,
 728         movl    %eax, %eax      # _9, _9
 729         movzwl  -2(%rsi,%rax), %edx     #, tmp148
 730         movw    %dx, -2(%r15,%rax)      # tmp148,
 731         jmp     .L26    #
 732         .p2align 4,,10
 733         .p2align 3
 734 .L27:
 735         movq    (%rsi), %rdx    #, tmp149
 736         leaq    96(%rbp), %rdi  #, tmp157
 737         andq    $-8, %rdi       #, tmp157
 738         movq    %rdx, 88(%rbp)  # tmp149,
 739         movl    %eax, %edx      # _9, _9
 740         movq    -8(%rsi,%rdx), %rcx     #, tmp156
 741         movq    %rcx, -8(%r15,%rdx)     # tmp156,
 742         subq    %rdi, %r15      # tmp157, _7
 743         leal    (%rax,%r15), %ecx       #, _9
 744         subq    %r15, %rsi      # _7, tmp130
 745         movl    %ecx, %eax      # _9, _9
 746         shrl    $3, %eax        #, _9
 747         movl    %eax, %ecx      # tmp158, tmp159
 748         rep movsq
 749         jmp     .L26    #
 750 .L61:
 751         movl    (%rsi), %edx    #, tmp132
 752         movl    %eax, %eax      # _9, _9
 753         movl    %edx, 88(%rbp)  # tmp132,
 754         movl    -4(%rsi,%rax), %edx     #, tmp139
 755         movl    %edx, -4(%r15,%rax)     # tmp139,
 756         jmp     .L26    #
 757         .p2align 4,,10
 758         .p2align 3
 759 .L57:
 760 # sha512.c:226:       memcpy (&ctx->buffer[left_over], buffer, len);
 761         movl    (%r12), %eax    #* buffer, tmp166
 762         movl    %eax, (%rdx)    # tmp166,
 763         movl    %ebx, %eax      # len, len
 764         movl    -4(%r12,%rax), %ecx     #, tmp173
 765         movl    %ecx, -4(%rdx,%rax)     # tmp173,
 766         jmp     .L34    #
 767 .L58:
 768         movl    %ebx, %eax      # len, len
 769         movzwl  -2(%r12,%rax), %ecx     #, tmp182
 770         movw    %cx, -2(%rdx,%rax)      # tmp182,
 771         jmp     .L34    #
 772         .cfi_endproc
 773 .LFE34:
 774         .size   __sha512_process_bytes, .-__sha512_process_bytes
 775         .section        .rodata
 776         .align 32
 777         .type   K, @object
 778         .size   K, 640
 779 K:
 780         .quad   4794697086780616226
 781         .quad   8158064640168781261
 782         .quad   -5349999486874862801
 783         .quad   -1606136188198331460
 784         .quad   4131703408338449720
 785         .quad   6480981068601479193
 786         .quad   -7908458776815382629
 787         .quad   -6116909921290321640
 788         .quad   -2880145864133508542
 789         .quad   1334009975649890238
 790         .quad   2608012711638119052
 791         .quad   6128411473006802146
 792         .quad   8268148722764581231
 793         .quad   -9160688886553864527
 794         .quad   -7215885187991268811
 795         .quad   -4495734319001033068
 796         .quad   -1973867731355612462
 797         .quad   -1171420211273849373
 798         .quad   1135362057144423861
 799         .quad   2597628984639134821
 800         .quad   3308224258029322869
 801         .quad   5365058923640841347
 802         .quad   6679025012923562964
 803         .quad   8573033837759648693
 804         .quad   -7476448914759557205
 805         .quad   -6327057829258317296
 806         .quad   -5763719355590565569
 807         .quad   -4658551843659510044
 808         .quad   -4116276920077217854
 809         .quad   -3051310485924567259
 810         .quad   489312712824947311
 811         .quad   1452737877330783856
 812         .quad   2861767655752347644
 813         .quad   3322285676063803686
 814         .quad   5560940570517711597
 815         .quad   5996557281743188959
 816         .quad   7280758554555802590
 817         .quad   8532644243296465576
 818         .quad   -9096487096722542874
 819         .quad   -7894198246740708037
 820         .quad   -6719396339535248540
 821         .quad   -6333637450476146687
 822         .quad   -4446306890439682159
 823         .quad   -4076793802049405392
 824         .quad   -3345356375505022440
 825         .quad   -2983346525034927856
 826         .quad   -860691631967231958
 827         .quad   1182934255886127544
 828         .quad   1847814050463011016
 829         .quad   2177327727835720531
 830         .quad   2830643537854262169
 831         .quad   3796741975233480872
 832         .quad   4115178125766777443
 833         .quad   5681478168544905931
 834         .quad   6601373596472566643
 835         .quad   7507060721942968483
 836         .quad   8399075790359081724
 837         .quad   8693463985226723168
 838         .quad   -8878714635349349518
 839         .quad   -8302665154208450068
 840         .quad   -8016688836872298968
 841         .quad   -6606660893046293015
 842         .quad   -4685533653050689259
 843         .quad   -4147400797238176981
 844         .quad   -3880063495543823972
 845         .quad   -3348786107499101689
 846         .quad   -1523767162380948706
 847         .quad   -757361751448694408
 848         .quad   500013540394364858
 849         .quad   748580250866718886
 850         .quad   1242879168328830382
 851         .quad   1977374033974150939
 852         .quad   2944078676154940804
 853         .quad   3659926193048069267
 854         .quad   4368137639120453308
 855         .quad   4836135668995329356
 856         .quad   5532061633213252278
 857         .quad   6448918945643986474
 858         .quad   6902733635092675308
 859         .quad   7801388544844847127
 860         .align 32
 861         .type   fillbuf, @object
 862         .size   fillbuf, 128
 863 fillbuf:
 864         .byte   -128
 865         .byte   0
 866         .zero   126
 867         .ident  "GCC: (GNU) 7.3.0"
 868         .section        .note.GNU-stack,"",@progbits