From bfd21c4fd77aaaa5d2f416b25f7a38a6b675a2f7 Mon Sep 17 00:00:00 2001 From: Paul Kehrer <161495+reaperhulk@users.noreply.github.com> Date: Thu, 1 Oct 2026 13:07:47 +0000 Subject: [PATCH 1/2] Vectorize x86-64 RC2 key-expansion table scans with SSE2 --- .../VerifiedGarbage/Artifacts/Rc2/X86_64.lean | 2 +- .../Impl/Rc2/X86_64/ExpandKey.lean | 10 +- .../Impl/Rc2/X86_64/Sse2Lookup.lean | 52 + .../Proof/Rc2/RestoreMemory.lean | 19 + .../Proof/Rc2/X86_64/DescendKey.lean | 6 +- .../Proof/Rc2/X86_64/FillKey.lean | 6 +- .../VerifiedGarbage/Proof/Rc2/X86_64/Key.lean | 8 +- .../Proof/Rc2/X86_64/KeyBody.lean | 20 +- .../Proof/Rc2/X86_64/KeySetup.lean | 12 +- .../Proof/Rc2/X86_64/KeySteps.lean | 24 +- .../Proof/Rc2/X86_64/Sse2Exec.lean | 86 + .../Proof/Rc2/X86_64/Sse2Finish.lean | 79 + .../Proof/Rc2/X86_64/Sse2Mask.lean | 46 + .../Proof/Rc2/X86_64/Sse2PiLookup.lean | 48 + .../Proof/Rc2/X86_64/Sse2Start.lean | 48 + .../Proof/Rc2/X86_64/Sse2Steps.lean | 65 + .../Proof/Rc2/X86_64/Sse2Vector.lean | 128 + src/asm/x86_64/rc2.rs | 6009 ++++------------- 18 files changed, 1951 insertions(+), 4717 deletions(-) create mode 100644 lean/VerifiedGarbage/Impl/Rc2/X86_64/Sse2Lookup.lean create mode 100644 lean/VerifiedGarbage/Proof/Rc2/RestoreMemory.lean create mode 100644 lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2Exec.lean create mode 100644 lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2Finish.lean create mode 100644 lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2Mask.lean create mode 100644 lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2PiLookup.lean create mode 100644 lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2Start.lean create mode 100644 lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2Steps.lean create mode 100644 lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2Vector.lean diff --git a/lean/VerifiedGarbage/Artifacts/Rc2/X86_64.lean b/lean/VerifiedGarbage/Artifacts/Rc2/X86_64.lean index 6e911d112..2abe94ffd 100644 --- a/lean/VerifiedGarbage/Artifacts/Rc2/X86_64.lean +++ b/lean/VerifiedGarbage/Artifacts/Rc2/X86_64.lean @@ -30,7 +30,7 @@ def artifacts : List Artifact := [ { Spec.Rc2.expandKeyApi with target := X86_64.target doc := Spec.Rc2.expandKeyApi.doc - (notes := ["Baseline x86-64. PITABLE selection scans all 256 candidates in a fixed order."]) + (notes := ["Baseline x86-64 SSE2. PITABLE selection scans all 256 candidates in a fixed order, eight candidates per vector."]) code := Impl.Rc2.X86_64.expandKey contract := Spec.Rc2.expandKeyContract X86_64.abi stack := 0 diff --git a/lean/VerifiedGarbage/Impl/Rc2/X86_64/ExpandKey.lean b/lean/VerifiedGarbage/Impl/Rc2/X86_64/ExpandKey.lean index 4bbaaaae6..cee0daf58 100644 --- a/lean/VerifiedGarbage/Impl/Rc2/X86_64/ExpandKey.lean +++ b/lean/VerifiedGarbage/Impl/Rc2/X86_64/ExpandKey.lean @@ -1,10 +1,10 @@ -import VerifiedGarbage.Impl.Rc2.X86_64.Lookup +import VerifiedGarbage.Impl.Rc2.X86_64.Sse2Lookup /-! # RC2 key expansion on baseline x86-64 The public key length controls copying and expansion. The effective bit count controls the reduction mask and descending loop. PITABLE selection -always scans all 256 candidates with arithmetic masks. +always scans all 256 candidates with eight parallel SSE2 arithmetic masks. -/ namespace VG.Impl.Rc2.X86_64 @@ -27,7 +27,7 @@ def copyKey : List Instr := def fillKey : List Instr := [.movzx8 .rax (indexed .r14 .rbx (-1)), rr .r9 .rbx, .alu .sub .r9 (.reg .r13), - .movzx8 .rcx (indexed .r14 .r9), .alu .add .rax (.reg .rcx)] ++ piLookup ++ + .movzx8 .rcx (indexed .r14 .r9), .alu .add .rax (.reg .rcx)] ++ Sse2.piLookup ++ [.store8 (indexed .r14 .rbx) .rax, .alu .add .rbx (.imm 1), .alu .cmp .rbx (.imm 128)] /-- TM = 2^(T1 mod 8) - 1, with TM = 255 for a multiple of eight. All @@ -39,13 +39,13 @@ def maskCode : Prog isa := (.seq (.ite .e (.block [imm .rdx (2 ^ (i + 1) - 1)]) (.block [])) rest)) (.block [])) def reduceKey : List Instr := - [.movzx8 .rax (indexed .r14 .rbx), .alu .and .rax (.reg .rdx)] ++ piLookup ++ + [.movzx8 .rax (indexed .r14 .rbx), .alu .and .rax (.reg .rdx)] ++ Sse2.piLookup ++ [.store8 (indexed .r14 .rbx) .rax] def descendKey : List Instr := [.alu .sub .rbx (.imm 1), .movzx8 .rax (indexed .r14 .rbx 1), rr .r9 .rbx, .alu .add .r9 (.reg .rbp), .movzx8 .rcx (indexed .r14 .r9), .alu .xor .rax (.reg .rcx)] ++ - piLookup ++ [.store8 (indexed .r14 .rbx) .rax, .alu .cmp .rbx (.imm 0)] + Sse2.piLookup ++ [.store8 (indexed .r14 .rbx) .rax, .alu .cmp .rbx (.imm 0)] def expandCopyFill : Prog isa := .seq (.loop (.block copyKey) .ne) diff --git a/lean/VerifiedGarbage/Impl/Rc2/X86_64/Sse2Lookup.lean b/lean/VerifiedGarbage/Impl/Rc2/X86_64/Sse2Lookup.lean new file mode 100644 index 000000000..bd830a30d --- /dev/null +++ b/lean/VerifiedGarbage/Impl/Rc2/X86_64/Sse2Lookup.lean @@ -0,0 +1,52 @@ +import VerifiedGarbage.Impl.Rc2.X86_64.Lookup + +/-! # Eight-way constant-time RC2 scans on baseline x86-64 + +SSE2 is part of the target baseline. Each word-sized XOR is at most 255; +subtracting one and shifting arithmetically produces a full equality mask. +The scans visit every candidate in order, eight candidates per vector. +The temporary vector store is restored before returning. +-/ + +namespace VG.Impl.Rc2.X86_64.Sse2 + +open VG.X86_64 VG.Impl.Rc2.X86_64 + +def loadConst (dst : XReg) (v : BitVec 128) : List Instr := + [.movImm64 .r10 (v.extractLsb' 0 64), .xop (.movq dst .r10), + .movImm64 .r10 (v.extractLsb' 64 64), .xop (.movq .xmm5 .r10), + .xop (.bin .punpcklqdq dst .xmm5)] + +def indices (n : Nat) : BitVec 128 := ofWords fun j => BitVec.ofNat 16 (8 * n + j) +def ones : BitVec 128 := ofWords fun _ => 1 +def eights : BitVec 128 := ofWords fun _ => 8 +def piValues (n : Nat) : BitVec 128 := + ofWords fun j => (VG.Spec.Rc2.piTable.getD (8 * n + j) 0).setWidth 16 + +def start (scratch : Reg) (mask : Nat) : List Instr := + [.movdquLoad .xmm8 (memOp scratch 64), .alu .and .rax (.imm (BitVec.ofNat 32 mask)), + .xop (.movq .xmm0 .rax), .xop (.bin .punpcklwd .xmm0 .xmm0), + .xop (.pshufd .xmm0 .xmm0 0), .xop (.bin .pxor .xmm1 .xmm1)] ++ + loadConst .xmm2 (indices 0) ++ loadConst .xmm6 ones ++ loadConst .xmm7 eights + +def select : List Instr := + [.xop (.bin .movdqa .xmm3 .xmm0), .xop (.bin .pxor .xmm3 .xmm2), + .xop (.bin .psubw .xmm3 .xmm6), .xop (.shift .psraw .xmm3 15), + .xop (.bin .pand .xmm3 .xmm4), .xop (.bin .por .xmm1 .xmm3), + .xop (.bin .paddw .xmm2 .xmm7)] + +def piStep (n : Nat) : List Instr := loadConst .xmm4 (piValues n) ++ select + +def reduceOr : List Instr := + [8, 4, 2].flatMap fun n => + [.xop (.bin .movdqa .xmm3 .xmm1), .xop (.shift .psrldq .xmm3 (BitVec.ofNat 8 n)), + .xop (.bin .por .xmm1 .xmm3)] + +def finish (scratch : Reg) : List Instr := reduceOr ++ + [.movdquStore (memOp scratch 64) .xmm1, .mov .rax (.mem (memOp scratch 64)), + .alu .and .rax (.imm 65535), .movdquStore (memOp scratch 64) .xmm8] + +def piLookup : List Instr := + start .r8 255 ++ (List.range 32).flatMap piStep ++ finish .r8 + +end VG.Impl.Rc2.X86_64.Sse2 diff --git a/lean/VerifiedGarbage/Proof/Rc2/RestoreMemory.lean b/lean/VerifiedGarbage/Proof/Rc2/RestoreMemory.lean new file mode 100644 index 000000000..adc15dd9a --- /dev/null +++ b/lean/VerifiedGarbage/Proof/Rc2/RestoreMemory.lean @@ -0,0 +1,19 @@ +import VerifiedGarbage.Proof.Framework.Mem + +/-! # Restoring a temporary vector store exactly -/ + +namespace VG.Proof.Rc2 + +theorem restore128 (m : VG.Mem) (p : VG.Addr) (v : BitVec 128) : + (m.writeW p v).writeW p (m.readW p 128) = m := by + funext q + by_cases h : (q - p).toNat < 16 + · simp only [VG.Mem.writeW, VG.Mem.write, BitVec.setWidth_eq, h, ite_true, + VG.Mem.readW] + rw [VG.Mem.extractLsb'_read m p h] + have he : p + BitVec.ofNat 64 (q - p).toNat = q := by + rw [BitVec.ofNat_toNat, BitVec.setWidth_eq, BitVec.add_comm p, BitVec.sub_add_cancel] + rw [he] + · simp only [VG.Mem.writeW, VG.Mem.write, h, ite_false] + +end VG.Proof.Rc2 diff --git a/lean/VerifiedGarbage/Proof/Rc2/X86_64/DescendKey.lean b/lean/VerifiedGarbage/Proof/Rc2/X86_64/DescendKey.lean index aca3b66c6..d1b535b34 100644 --- a/lean/VerifiedGarbage/Proof/Rc2/X86_64/DescendKey.lean +++ b/lean/VerifiedGarbage/Proof/Rc2/X86_64/DescendKey.lean @@ -6,7 +6,8 @@ namespace VG.Proof.Rc2.X86_64 open VG VG.X86_64 VG.Impl.Rc2.X86_64 -theorem descendLoop_ok (s : State) (l : KeyBytes) (t8 : Nat) (ht : 1 ≤ t8) (ht' : t8 < 128) +theorem descendLoop_ok (s : State) + (hlookup : InRegions s.wr (s.gpr .r8 + BitVec.ofNat 64 64) 16) (l : KeyBytes) (t8 : Nat) (ht : 1 ≤ t8) (ht' : t8 < 128) (len : s.gpr .rbp = BitVec.ofNat 64 t8) (start : s.gpr .rbx = BitVec.ofNat 64 (128 - t8)) (writable : ∀ i < 128, InRegions s.wr (s.gpr .r14 + BitVec.ofNat 64 i) 1) (initialPrefix : BytesPrefix s.mem (s.gpr .r14) l 128) : @@ -48,7 +49,8 @@ theorem descendLoop_ok (s : State) (l : KeyBytes) (t8 : Nat) (ht : 1 ≤ t8) (ht rw [loAddr]; exact read₁ _ (by omega) have readHi : InRegions (s₁.rd ++ s₁.wr) (s₁.gpr .r14 + (s₁.gpr .rbx - 1#64 + s₁.gpr .rbp)) 1 := by rw [hiAddr]; exact read₁ _ (by omega) - apply WP.mono (descendKey_ok s₁ readLo readHi write₁) + apply WP.mono (descendKey_ok s₁ (by + rw [frame₁.wr, frame₁.reg .r8 (by decide)]; exact hlookup) readLo readHi write₁) intro s₂ h₂ let b := Spec.Rc2.pi ((descend l t8 j).getD (127 - t8 - j + 1) 0 ^^^ (descend l t8 j).getD (127 - t8 - j + t8) 0) diff --git a/lean/VerifiedGarbage/Proof/Rc2/X86_64/FillKey.lean b/lean/VerifiedGarbage/Proof/Rc2/X86_64/FillKey.lean index 56cc0a411..1ff3a5f56 100644 --- a/lean/VerifiedGarbage/Proof/Rc2/X86_64/FillKey.lean +++ b/lean/VerifiedGarbage/Proof/Rc2/X86_64/FillKey.lean @@ -6,7 +6,8 @@ namespace VG.Proof.Rc2.X86_64 open VG VG.X86_64 VG.Impl.Rc2.X86_64 -theorem fillLoop_ok (s : State) (key : List Byte) (ht : 1 ≤ key.length) (ht' : key.length < 128) +theorem fillLoop_ok (s : State) + (hlookup : InRegions s.wr (s.gpr .r8 + BitVec.ofNat 64 64) 16) (key : List Byte) (ht : 1 ≤ key.length) (ht' : key.length < 128) (len : s.gpr .r13 = BitVec.ofNat 64 key.length) (start : s.gpr .rbx = BitVec.ofNat 64 key.length) (writable : ∀ i < 128, InRegions s.wr (s.gpr .r14 + BitVec.ofNat 64 i) 1) (initialPrefix : BytesPrefix s.mem (s.gpr .r14) (fill key 0) key.length) : @@ -45,7 +46,8 @@ theorem fillLoop_ok (s : State) (key : List Byte) (ht : 1 ≤ key.length) (ht' : rw [loAddr]; exact read₁ _ (by omega) have readHi : InRegions (s₁.rd ++ s₁.wr) (s₁.gpr .r14 + (s₁.gpr .rbx - s₁.gpr .r13)) 1 := by rw [hiAddr]; exact read₁ _ (by omega) - apply WP.mono (fillKey_ok s₁ readLo readHi write₁) + apply WP.mono (fillKey_ok s₁ (by + rw [frame₁.wr, frame₁.reg .r8 (by decide)]; exact hlookup) readLo readHi write₁) intro s₂ h₂ let b := Spec.Rc2.pi ((fill key j).getD (key.length + j - 1) 0 + (fill key j).getD j 0) have keep₂ : Keep keyTemps {s₁ with diff --git a/lean/VerifiedGarbage/Proof/Rc2/X86_64/Key.lean b/lean/VerifiedGarbage/Proof/Rc2/X86_64/Key.lean index da4825489..67190fa2d 100644 --- a/lean/VerifiedGarbage/Proof/Rc2/X86_64/Key.lean +++ b/lean/VerifiedGarbage/Proof/Rc2/X86_64/Key.lean @@ -59,14 +59,18 @@ theorem key_body_correct (s : State) (hs : keyContract.pre s) : intro i hi rw [wr₂, ptr₂, hwr] exact ⟨⟨s.gpr .rcx, 128⟩, by simp, Offset.contains_base _ (by omega) (by omega)⟩ + have lookup₂ : InRegions s₂.wr (s₂.gpr .r8 + BitVec.ofNat 64 64) 16 := by + rw [wr₂, r8₂, hwr] + exact ⟨⟨s.gpr .r8, 512⟩, by simp, Offset.contains_base _ (by decide) (by decide)⟩ apply WP.seq - apply WP.mono (expandCopyFill_ok s₂ (s.gpr .rsi).toNat ht ht' + apply WP.mono (expandCopyFill_ok s₂ lookup₂ (s.gpr .rsi).toNat ht ht' (by simpa using len₂) zero₂ read₂ write₂ (by rw [key₂, ptr₂]; exact keyOut)) intro s₃ h₃ apply WP.seq have write₃ : ∀ i < 128, InRegions s₃.wr (s₃.gpr .r14 + BitVec.ofNat 64 i) 1 := by rw [h₃.1.wr, h₃.1.reg .r14 (by decide)]; exact write₂ - apply WP.mono (expandReduce_ok s₃ _ (s.gpr .rdx).toNat hb hb' + apply WP.mono (expandReduce_ok s₃ (by + rw [h₃.1.wr, h₃.1.reg .r8 (by decide)]; exact lookup₂) _ (s.gpr .rdx).toNat hb hb' (by simpa using (h₃.1.reg .r15 (by decide)).trans bits₂) write₃ (by rw [h₃.1.reg .r14 (by decide)]; exact h₃.2)) intro s₄ h₄ diff --git a/lean/VerifiedGarbage/Proof/Rc2/X86_64/KeyBody.lean b/lean/VerifiedGarbage/Proof/Rc2/X86_64/KeyBody.lean index d5c0ff172..103b0c1b1 100644 --- a/lean/VerifiedGarbage/Proof/Rc2/X86_64/KeyBody.lean +++ b/lean/VerifiedGarbage/Proof/Rc2/X86_64/KeyBody.lean @@ -31,7 +31,8 @@ theorem CoreFrame.trans {s₀ s₁ s₂ : State} (h₁ : CoreFrame s₀ s₁) (h rw [h₁.reg .r14 (by decide)] at frame₂ exact h₁.mem.trans frame₂ -theorem expandCopyFill_ok (s : State) (t : Nat) (ht : 1 ≤ t) (ht' : t ≤ 128) +theorem expandCopyFill_ok (s : State) + (hlookup : InRegions s.wr (s.gpr .r8 + BitVec.ofNat 64 64) 16) (t : Nat) (ht : 1 ≤ t) (ht' : t ≤ 128) (len : s.gpr .r13 = BitVec.ofNat 64 t) (zero : s.gpr .rbx = 0) (readable : ∀ i < t, InRegions (s.rd ++ s.wr) (s.gpr .r12 + BitVec.ofNat 64 i) 1) (writable : ∀ i < 128, InRegions s.wr (s.gpr .r14 + BitVec.ofNat 64 i) 1) @@ -47,14 +48,16 @@ theorem expandCopyFill_ok (s : State) (t : Nat) (ht : 1 ≤ t) (ht' : t ≤ 128) have ptr₁ := h₁.2.1.reg .r14 (by decide) have writes : ∀ i < 128, InRegions s₁.wr (s₁.gpr .r14 + BitVec.ofNat 64 i) 1 := by rw [h₁.2.1.wr, ptr₁]; exact writable - apply WP.mono (maybeFill_ok s₁ (Spec.Rc2.bytesAt s.mem (s.gpr .r12) t) + apply WP.mono (maybeFill_ok s₁ (by + rw [h₁.2.1.wr, h₁.2.1.reg .r8 (by decide)]; exact hlookup) (Spec.Rc2.bytesAt s.mem (s.gpr .r12) t) (by rw [length]; exact ht) (by rw [length]; exact ht') (by rw [length]; exact (h₁.2.1.reg .r13 (by decide)).trans len) (by rw [length]; exact h₁.1) writes (by rw [ptr₁, length]; exact h₁.2.2)) intro s₂ h₂ exact ⟨h₁.2.1.trans h₂.2.1, by rw [length, ptr₁] at h₂; exact h₂.2.2⟩ -theorem reduceDescend_ok (s : State) (l : KeyBytes) (bits : Nat) (hb : 1 ≤ bits) (hb' : bits ≤ 1024) +theorem reduceDescend_ok (s : State) + (hlookup : InRegions s.wr (s.gpr .r8 + BitVec.ofNat 64 64) 16) (l : KeyBytes) (bits : Nat) (hb : 1 ≤ bits) (hb' : bits ≤ 1024) (len : s.gpr .rbp = BitVec.ofNat 64 ((bits + 7) / 8)) (index : s.gpr .rbx = BitVec.ofNat 64 (128 - (bits + 7) / 8)) (mask : (s.gpr .rdx).setWidth 8 = BitVec.ofNat 8 (255 % 2 ^ (8 + bits - 8 * ((bits + 7) / 8)))) @@ -71,7 +74,7 @@ theorem reduceDescend_ok (s : State) (l : KeyBytes) (bits : Nat) (hb : 1 ≤ bit obtain ⟨r, hr, hc⟩ := writes exact ⟨r, List.mem_append_right _ hr, hc⟩ apply WP.seq - apply WP.mono (reduceKey_ok s reads writes) + apply WP.mono (reduceKey_ok s hlookup reads writes) intro s₁ h₁ have keep₁ := h₁.2 rw [index, initialPrefix _ (by omega), mask] at keep₁ @@ -82,13 +85,15 @@ theorem reduceDescend_ok (s : State) (l : KeyBytes) (bits : Nat) (hb : 1 ≤ bit exact initialPrefix.write (by decide) (by omega) _ have write₁ : ∀ i < 128, InRegions s₁.wr (s₁.gpr .r14 + BitVec.ofNat 64 i) 1 := by rw [keep₁.wr, ptr₁]; exact writable - apply WP.mono (maybeDescend_ok s₁ (reduce l bits) ((bits + 7) / 8) bound.1 bound.2 + apply WP.mono (maybeDescend_ok s₁ (by + rw [keep₁.wr, keep₁.reg .r8 (by decide)]; exact hlookup) (reduce l bits) ((bits + 7) / 8) bound.1 bound.2 ((keep₁.reg .rbp (by decide)).trans len) (h₁.1.trans index) write₁ (by rw [ptr₁]; exact prefix₁)) intro s₂ h₂ exact ⟨frame₁.trans h₂.1, by rw [ptr₁] at h₂; exact h₂.2⟩ -theorem expandReduce_ok (s : State) (l : KeyBytes) (bits : Nat) (hb : 1 ≤ bits) (hb' : bits ≤ 1024) +theorem expandReduce_ok (s : State) + (hlookup : InRegions s.wr (s.gpr .r8 + BitVec.ofNat 64 64) 16) (l : KeyBytes) (bits : Nat) (hb : 1 ≤ bits) (hb' : bits ≤ 1024) (input : s.gpr .r15 = BitVec.ofNat 64 bits) (writable : ∀ i < 128, InRegions s.wr (s.gpr .r14 + BitVec.ofNat 64 i) 1) (initialPrefix : BytesPrefix s.mem (s.gpr .r14) l 128) : @@ -105,7 +110,8 @@ theorem expandReduce_ok (s : State) (l : KeyBytes) (bits : Nat) (hb : 1 ≤ bits have ptr₂ := frame.reg .r14 (by decide) have writes : ∀ i < 128, InRegions s₂.wr (s₂.gpr .r14 + BitVec.ofNat 64 i) 1 := by rw [frame.wr, ptr₂]; exact writable - apply WP.mono (reduceDescend_ok s₂ l bits hb hb' + apply WP.mono (reduceDescend_ok s₂ (by + rw [frame.wr, frame.reg .r8 (by decide)]; exact hlookup) l bits hb hb' ((h₂.2.reg .rbp (by decide)).trans len₁) ((h₂.2.reg .rbx (by decide)).trans index₁) h₂.1 writes (by rw [ptr₂, h₂.2.mem, keep₁.mem]; exact initialPrefix)) intro s₃ h₃ diff --git a/lean/VerifiedGarbage/Proof/Rc2/X86_64/KeySetup.lean b/lean/VerifiedGarbage/Proof/Rc2/X86_64/KeySetup.lean index ce58a1859..bb4bf11bf 100644 --- a/lean/VerifiedGarbage/Proof/Rc2/X86_64/KeySetup.lean +++ b/lean/VerifiedGarbage/Proof/Rc2/X86_64/KeySetup.lean @@ -17,7 +17,8 @@ theorem cmp128_ok (s : State) : rfl, ?_⟩ exact ⟨zf_arithFlags _ _ _ _, ⟨fun _ _ => rfl, rfl, rfl, rfl⟩⟩ -theorem maybeFill_ok (s : State) (key : List Byte) (ht : 1 ≤ key.length) (ht' : key.length ≤ 128) +theorem maybeFill_ok (s : State) + (hlookup : InRegions s.wr (s.gpr .r8 + BitVec.ofNat 64 64) 16) (key : List Byte) (ht : 1 ≤ key.length) (ht' : key.length ≤ 128) (len : s.gpr .r13 = BitVec.ofNat 64 key.length) (start : s.gpr .rbx = BitVec.ofNat 64 key.length) (writable : ∀ i < 128, InRegions s.wr (s.gpr .r14 + BitVec.ofNat 64 i) 1) (initialPrefix : BytesPrefix s.mem (s.gpr .r14) (fill key 0) key.length) : @@ -48,7 +49,8 @@ theorem maybeFill_ok (s : State) (key : List Byte) (ht : 1 ≤ key.length) (ht' rw [keep₁.wr, ptr₁]; exact writable have initial : BytesPrefix s₁.mem (s₁.gpr .r14) (fill key 0) key.length := by rw [keep₁.mem, ptr₁]; exact initialPrefix - apply WP.mono (fillLoop_ok s₁ key ht (by omega) + apply WP.mono (fillLoop_ok s₁ (by + rw [keep₁.wr, keep₁.reg .r8 (by simp)]; exact hlookup) key ht (by omega) ((keep₁.reg .r13 (by simp)).trans len) ((keep₁.reg .rbx (by simp)).trans start) writes initial) intro s₂ h₂ exact ⟨h₂.1, frame₁.trans h₂.2.1, by rw [ptr₁] at h₂; exact h₂.2.2⟩ @@ -85,7 +87,8 @@ theorem setReduction_ok (s : State) (bits : Nat) (hb : 1 ≤ bits) (hb' : bits · simp only [rd_setReg, rd_arithFlags, rd_setFlags] · simp only [wr_setReg, wr_arithFlags, wr_setFlags] -theorem maybeDescend_ok (s : State) (l : KeyBytes) (t8 : Nat) (ht : 1 ≤ t8) (ht' : t8 ≤ 128) +theorem maybeDescend_ok (s : State) + (hlookup : InRegions s.wr (s.gpr .r8 + BitVec.ofNat 64 64) 16) (l : KeyBytes) (t8 : Nat) (ht : 1 ≤ t8) (ht' : t8 ≤ 128) (len : s.gpr .rbp = BitVec.ofNat 64 t8) (start : s.gpr .rbx = BitVec.ofNat 64 (128 - t8)) (writable : ∀ i < 128, InRegions s.wr (s.gpr .r14 + BitVec.ofNat 64 i) 1) (initialPrefix : BytesPrefix s.mem (s.gpr .r14) l 128) : @@ -119,7 +122,8 @@ theorem maybeDescend_ok (s : State) (l : KeyBytes) (t8 : Nat) (ht : 1 ≤ t8) (h rw [keep₁.wr, ptr₁]; exact writable have initial : BytesPrefix s₁.mem (s₁.gpr .r14) l 128 := by rw [keep₁.mem, ptr₁]; exact initialPrefix - apply WP.mono (descendLoop_ok s₁ l t8 ht (by omega) + apply WP.mono (descendLoop_ok s₁ (by + rw [keep₁.wr, keep₁.reg .r8 (by simp)]; exact hlookup) l t8 ht (by omega) ((keep₁.reg .rbp (by simp)).trans len) ((keep₁.reg .rbx (by simp)).trans start) writes initial) intro s₂ h₂ exact ⟨frame₁.trans h₂.2.1, by rw [ptr₁] at h₂; exact h₂.2.2⟩ diff --git a/lean/VerifiedGarbage/Proof/Rc2/X86_64/KeySteps.lean b/lean/VerifiedGarbage/Proof/Rc2/X86_64/KeySteps.lean index 56ff38223..8c702c010 100644 --- a/lean/VerifiedGarbage/Proof/Rc2/X86_64/KeySteps.lean +++ b/lean/VerifiedGarbage/Proof/Rc2/X86_64/KeySteps.lean @@ -1,3 +1,4 @@ +import VerifiedGarbage.Proof.Rc2.X86_64.Sse2PiLookup import VerifiedGarbage.Impl.Rc2.X86_64.ExpandKey import VerifiedGarbage.Proof.Rc2.X86_64.Save import VerifiedGarbage.Proof.Rc2.Expansion @@ -95,6 +96,7 @@ theorem fillOutput_ok (s : State) · simp only [wr_arithFlags, wr_setReg] theorem fillKey_ok (s : State) + (hlookup : InRegions s.wr (s.gpr .r8 + BitVec.ofNat 64 64) 16) (readLo : InRegions (s.rd ++ s.wr) (s.gpr .r14 + s.gpr .rbx - 1#64) 1) (readHi : InRegions (s.rd ++ s.wr) (s.gpr .r14 + (s.gpr .rbx - s.gpr .r13)) 1) (writable : InRegions s.wr (s.gpr .r14 + s.gpr .rbx) 1) : @@ -109,7 +111,8 @@ theorem fillKey_ok (s : State) obtain ⟨s₁, run₁, out₁, keep₁⟩ := fillInput_ok s readLo readHi refine WP.of_runBlock ⟨s₁, run₁, ?_⟩ rw [WP.block_append_iff] - apply WP.mono (piLookup_ok s₁) + apply WP.mono (Sse2.piLookup_ok s₁ (by + rw [keep₁.wr, keep₁.reg .r8 (by decide)]; exact hlookup)) intro s₂ h₂ have k₁ : Keep keyTemps s s₁ := keep₁.weaken (by intro r hr @@ -195,13 +198,14 @@ theorem descendInput_ok (s : State) · simp only [rd_setReg, rd_arithFlags] · simp only [wr_setReg, wr_arithFlags] -theorem piStore_ok (s : State) (writable : InRegions s.wr (s.gpr .r14 + s.gpr .rbx) 1) : - WP isa (.block (piLookup ++ ([.store8 (indexed .r14 .rbx) .rax] : List Instr))) s (fun s' => +theorem piStore_ok (s : State) + (hlookup : InRegions s.wr (s.gpr .r8 + BitVec.ofNat 64 64) 16) (writable : InRegions s.wr (s.gpr .r14 + s.gpr .rbx) 1) : + WP isa (.block (Sse2.piLookup ++ ([.store8 (indexed .r14 .rbx) .rax] : List Instr))) s (fun s' => s'.gpr .rbx = s.gpr .rbx ∧ Keep keyTemps {s with mem := s.mem.writeW (s.gpr .r14 + s.gpr .rbx) (Spec.Rc2.pi ((s.gpr .rax).setWidth 8))} s') := by rw [WP.block_append_iff] - apply WP.mono (piLookup_ok s) + apply WP.mono (Sse2.piLookup_ok s hlookup) intro s₁ h₁ have ptr := h₁.2.reg .r14 (by decide) have index := h₁.2.reg .rbx (by decide) @@ -221,6 +225,7 @@ theorem piStore_ok (s : State) (writable : InRegions s.wr (s.gpr .r14 + s.gpr .r · exact h₁.2.wr theorem reduceKey_ok (s : State) + (hlookup : InRegions s.wr (s.gpr .r8 + BitVec.ofNat 64 64) 16) (readable : InRegions (s.rd ++ s.wr) (s.gpr .r14 + s.gpr .rbx) 1) (writable : InRegions s.wr (s.gpr .r14 + s.gpr .rbx) 1) : WP isa (.block reduceKey) s (fun s' => s'.gpr .rbx = s.gpr .rbx ∧ @@ -234,7 +239,8 @@ theorem reduceKey_ok (s : State) have index := keep₁.reg .rbx (by decide) have valid : InRegions s₁.wr (s₁.gpr .r14 + s₁.gpr .rbx) 1 := by rw [keep₁.wr, ptr, index]; exact writable - apply WP.mono (piStore_ok s₁ valid) + apply WP.mono (piStore_ok s₁ (by + rw [keep₁.wr, keep₁.reg .r8 (by decide)]; exact hlookup) valid) intro s₂ h₂ refine ⟨h₂.1.trans index, ?_⟩ constructor @@ -260,6 +266,7 @@ theorem cmpZero_ok (s : State) : · exact ⟨fun _ _ => rfl, rfl, rfl, rfl⟩ theorem descendKey_ok (s : State) + (hlookup : InRegions s.wr (s.gpr .r8 + BitVec.ofNat 64 64) 16) (readLo : InRegions (s.rd ++ s.wr) (s.gpr .r14 + (s.gpr .rbx - 1#64) + 1#64) 1) (readHi : InRegions (s.rd ++ s.wr) (s.gpr .r14 + (s.gpr .rbx - 1#64 + s.gpr .rbp)) 1) (writable : InRegions s.wr (s.gpr .r14 + (s.gpr .rbx - 1#64)) 1) : @@ -275,11 +282,12 @@ theorem descendKey_ok (s : State) have ptr := keep₁.reg .r14 (by decide) have valid : InRegions s₁.wr (s₁.gpr .r14 + s₁.gpr .rbx) 1 := by rw [keep₁.wr, ptr, index₁]; exact writable - have split : piLookup ++ [.store8 (indexed .r14 .rbx) .rax, .alu .cmp .rbx (.imm 0)] = - (piLookup ++ ([.store8 (indexed .r14 .rbx) .rax] : List Instr)) ++ [.alu .cmp .rbx (.imm 0)] := by + have split : Sse2.piLookup ++ [.store8 (indexed .r14 .rbx) .rax, .alu .cmp .rbx (.imm 0)] = + (Sse2.piLookup ++ ([.store8 (indexed .r14 .rbx) .rax] : List Instr)) ++ [.alu .cmp .rbx (.imm 0)] := by rw [List.append_assoc]; rfl rw [split, WP.block_append_iff] - apply WP.mono (piStore_ok s₁ valid) + apply WP.mono (piStore_ok s₁ (by + rw [keep₁.wr, keep₁.reg .r8 (by decide)]; exact hlookup) valid) intro s₂ h₂ obtain ⟨s₃, run₃, flag₃, keep₃⟩ := cmpZero_ok s₂ refine WP.of_runBlock ⟨s₃, run₃, ?_⟩ diff --git a/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2Exec.lean b/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2Exec.lean new file mode 100644 index 000000000..68f71cd80 --- /dev/null +++ b/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2Exec.lean @@ -0,0 +1,86 @@ +import VerifiedGarbage.Impl.Rc2.X86_64.Sse2Lookup +import VerifiedGarbage.Proof.Rc2.X86_64.Lookup +import VerifiedGarbage.Proof.Rc2.X86_64.Sse2Mask + +/-! # Register-only SSE2 RC2 lookup steps -/ + +namespace VG.Proof.Rc2.X86_64.Sse2 + +open VG VG.X86_64 VG.X86_64.RegUpd + +structure KeepX (regs : List Reg) (xregs : List XReg) (s s' : State) : Prop where + keep : Keep regs s s' + xmm : ∀ r, r ∉ xregs → s'.xmm r = s.xmm r + +theorem KeepX.trans {rs : List Reg} {xs : List XReg} {s s' s'' : State} + (h : KeepX rs xs s s') (h' : KeepX rs xs s' s'') : KeepX rs xs s s'' := + ⟨h.keep.trans h'.keep, fun r hr => (h'.xmm r hr).trans (h.xmm r hr)⟩ + +theorem loadConst_ok (s : State) (dst : XReg) (hd : dst ≠ .xmm5) (v : BitVec 128) : + ∃ s', runBlock isa (Impl.Rc2.X86_64.Sse2.loadConst dst v) s = some s' ∧ + s'.xmm dst = v ∧ KeepX [.r10] [dst, .xmm5] s s' := by + refine ⟨_, by + simp only [Impl.Rc2.X86_64.Sse2.loadConst, runBlock_cons, runStep_some, + runBlock_nil, exec, XOp.exec, gpr_setReg, + gpr_setXmm, xmm_setReg, xmm_setXmm_self, xmm_setXmm_of_ne _ _ hd] + rfl, ?_⟩ + constructor + · simp only [xmm_setXmm_self] + exact movq_const v + · constructor + · constructor + · intro r hr + simp only [List.mem_cons, List.not_mem_nil, or_false] at hr + simp only [gpr_setXmm, gpr_setReg_of_ne _ _ hr] + · simp only [mem_setXmm, mem_setReg] + · simp only [rd_setXmm, rd_setReg] + · simp only [wr_setXmm, wr_setReg] + · intro r hr + simp only [List.mem_cons, List.not_mem_nil, or_false, not_or] at hr + simp only [xmm_setXmm_of_ne _ _ hr.1, xmm_setXmm_of_ne _ _ hr.2, xmm_setReg] + +def selectValue (a b c v : BitVec 128) : BitVec 128 := + XBinOp.eval .pand + (XShiftOp.eval .psraw (XBinOp.eval .psubw (a ^^^ b) c) 15) v + +theorem select_ok (s : State) : + ∃ s', runBlock isa Impl.Rc2.X86_64.Sse2.select s = some s' ∧ + s'.xmm .xmm1 = s.xmm .xmm1 ||| + selectValue (s.xmm .xmm0) (s.xmm .xmm2) (s.xmm .xmm6) (s.xmm .xmm4) ∧ + s'.xmm .xmm2 = XBinOp.eval .paddw (s.xmm .xmm2) (s.xmm .xmm7) ∧ + KeepX [] [.xmm3, .xmm1, .xmm2] s s' := by + refine ⟨_, by + simp (config := {decide := true}) only [Impl.Rc2.X86_64.Sse2.select, + runBlock_cons, runStep_some, runBlock_nil, exec, XOp.exec, + xmm_setXmm_self, xmm_setXmm_of_ne] + rfl, ?_⟩ + refine ⟨?_, ?_, ?_⟩ + · simp (config := {decide := true}) only [selectValue, xmm_setXmm_self, + xmm_setXmm_of_ne, XBinOp.eval] + · exact xmm_setXmm_self _ _ _ + · constructor + · constructor + · intro r _; simp only [gpr_setXmm] + · simp only [mem_setXmm] + · simp only [rd_setXmm] + · simp only [wr_setXmm] + · intro r hr + simp only [List.mem_cons, List.not_mem_nil, or_false, not_or] at hr + simp only [xmm_setXmm_of_ne _ _ hr.1, xmm_setXmm_of_ne _ _ hr.2.1, + xmm_setXmm_of_ne _ _ hr.2.2] + +theorem selectValue_word (a b v : BitVec 128) (x y : Byte) (i : Nat) (hi : i < 8) + (ha : word a i = x.setWidth 16) (hb : word b i = y.setWidth 16) : + word (selectValue a b Impl.Rc2.X86_64.Sse2.ones v) i = + if x = y then word v i else 0 := by + rw [selectValue, word_pand, word_psraw _ _ hi, word_psubw _ _ hi] + rw [show (15 : BitVec 8).toNat = 15 by decide, Nat.min_eq_left (by decide)] + rw [show word (a ^^^ b) i = word a i ^^^ word b i from word_pxor a b] + rw [Impl.Rc2.X86_64.Sse2.ones, word_ofWords _ hi, ha, hb, mask_eq] + by_cases h : x = y + · rw [ite_eq_left h, ite_eq_left h, BitVec.allOnes_and] + · rw [ite_eq_right h, ite_eq_right h] + change 0#16 &&& word v i = 0#16 + exact BitVec.zero_and + +end VG.Proof.Rc2.X86_64.Sse2 diff --git a/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2Finish.lean b/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2Finish.lean new file mode 100644 index 000000000..4a5ea5d00 --- /dev/null +++ b/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2Finish.lean @@ -0,0 +1,79 @@ +import VerifiedGarbage.Proof.Rc2.X86_64.Sse2Vector +import VerifiedGarbage.Proof.Rc2.RestoreMemory +import VerifiedGarbage.Proof.Rc2.Word + +/-! # Reducing a scan and restoring its temporary memory -/ + +namespace VG.Proof.Rc2.X86_64.Sse2 + +open VG VG.X86_64 VG.X86_64.RegUpd VG.Impl.Rc2.X86_64 + +theorem reduceOr_ok (s : State) : + ∃ s', runBlock isa Sse2.reduceOr s = some s' ∧ + s'.xmm .xmm1 = reduceValue (s.xmm .xmm1) ∧ + KeepX [] [.xmm1, .xmm3] s s' := by + refine ⟨_, by + simp (config := {decide := true}) only [Sse2.reduceOr, List.flatMap_cons, + List.flatMap_nil, List.cons_append, List.nil_append, runBlock_cons, + runStep_some, runBlock_nil, exec, XOp.exec, xmm_setXmm_self, xmm_setXmm_of_ne] + rfl, ?_⟩ + constructor + · simp (config := {decide := true}) only [xmm_setXmm_self, + XBinOp.eval, XShiftOp.eval] + rfl + · constructor + · constructor + · intro r _; simp only [gpr_setXmm] + · simp only [mem_setXmm] + · simp only [rd_setXmm] + · simp only [wr_setXmm] + · intro r hr + simp only [List.mem_cons, List.not_mem_nil, or_false, not_or] at hr + simp only [xmm_setXmm_of_ne _ _ hr.1, xmm_setXmm_of_ne _ _ hr.2] + +theorem read64_word (m : Mem) (p : Addr) : + (m.readW p 64).setWidth 16 = m.readW p 16 := by + apply BitVec.eq_of_getLsbD_eq + intro j hj + simp only [Mem.readW, BitVec.getLsbD_setWidth, decide_eq_true hj, decide_eq_true (by omega : j < 64), Bool.true_and] + rw [getLsbD_read _ _ (by omega), getLsbD_read _ _ (by omega)] + +theorem stored_word (m : Mem) (p : Addr) (v : BitVec 128) : + (m.writeW p v).readW p 64 &&& 65535 = (word v 0).setWidth 64 := by + rw [maskWord, read64_word] + have he := readW_writeW128_16 m p v (j := 0) (by decide) + change (m.writeW p v).readW (p + 0#64) 16 = word v 0 at he + rw [BitVec.add_zero] at he + rw [he] + +theorem finishTail_ok (s : State) (scratch : Reg) (hs : scratch ≠ .rax) + (hread : InRegions (s.rd ++ s.wr) (s.gpr scratch + BitVec.ofNat 64 64) 8) + (hwrite : InRegions s.wr (s.gpr scratch + BitVec.ofNat 64 64) 16) + (hrestore : s.xmm .xmm8 = s.mem.readW (s.gpr scratch + BitVec.ofNat 64 64) 128) : + ∃ s', runBlock isa + [.movdquStore (memOp scratch 64) .xmm1, .mov .rax (.mem (memOp scratch 64)), + .alu .and .rax (.imm 65535), .movdquStore (memOp scratch 64) .xmm8] s = some s' ∧ + s'.gpr .rax = (word (s.xmm .xmm1) 0).setWidth 64 ∧ Keep [.rax] s s' := by + refine ⟨_, by + simp only [runBlock_cons, runStep_some, runBlock_nil, exec, execAlu, readSrc, + State.store128, State.load64, State.ea, memOp, offset_nat, gpr_setReg_of_ne _ _ hs, + gpr_arithFlags, gpr_setReg_self, xmm_setReg, xmm_arithFlags, + wr_setReg, wr_arithFlags, hread, hwrite, ite_true, Option.bind_some, Option.map_some] + rfl, ?_⟩ + constructor + · simp only [gpr_setReg_self] + change (s.mem.writeW _ (s.xmm .xmm1)).readW _ 64 &&& + (65535#32).signExtend 64 = _ + rw [show (65535#32).signExtend 64 = (65535 : BitVec 64) by decide] + exact stored_word _ _ _ + · constructor + · intro r hr + simp only [List.mem_cons, List.not_mem_nil, or_false] at hr + simp only [gpr_setReg_of_ne _ _ hr, gpr_arithFlags] + · simp only [mem_setReg, mem_arithFlags, hrestore] + exact restore128 _ _ _ + · simp only [rd_setReg, rd_arithFlags] + · rfl + + +end VG.Proof.Rc2.X86_64.Sse2 diff --git a/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2Mask.lean b/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2Mask.lean new file mode 100644 index 000000000..7ad852e05 --- /dev/null +++ b/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2Mask.lean @@ -0,0 +1,46 @@ +import VerifiedGarbage.Proof.Framework.X86_64.Words +import VerifiedGarbage.Proof.Rc2.Select + +/-! # Word-sized equality masks for SSE2 RC2 scans -/ + +namespace VG.Proof.Rc2.X86_64.Sse2 + +private theorem shift_mask (v : BitVec 16) (hb : v.toNat < 256) + (hn : v.toNat ≠ 0) : (v - 1).sshiftRight 15 = 0 := by + have hv : (v - 1).toNat = v.toNat - 1 := by + rw [BitVec.toNat_sub_of_le (by bv_omega)] + rfl + have hs : (v - 1).msb = false := by + rw [BitVec.msb_eq_false_iff_two_mul_lt, hv] + omega + rw [BitVec.sshiftRight_eq_of_msb_false hs] + apply BitVec.eq_of_toNat_eq + rw [BitVec.toNat_ushiftRight, hv] + rw [Nat.shiftRight_eq_div_pow, show (0 : BitVec 16).toNat = 0 by decide] + change (v.toNat - 1) / 32768 = 0 + omega + +theorem mask_eq (x y : VG.Byte) : + ((x.setWidth 16 ^^^ y.setWidth 16) - 1).sshiftRight 15 = + if x = y then BitVec.allOnes 16 else 0 := by + have hb : (x.setWidth 16 ^^^ y.setWidth 16).toNat < 256 := by + rw [← BitVec.setWidth_xor] + simp only [BitVec.toNat_setWidth] + have h := (x ^^^ y).isLt + omega + by_cases h : x = y + · subst y + rw [BitVec.xor_self, ite_eq_left rfl] + decide + · have hn : x.setWidth 16 ^^^ y.setWidth 16 ≠ 0#16 := by + intro hz + have he := BitVec.xor_eq_zero_iff.mp hz + have he' := congrArg (BitVec.setWidth 8) he + exact h (by simpa using he') + have hn' : (x.setWidth 16 ^^^ y.setWidth 16).toNat ≠ 0 := by + intro hz + exact hn (BitVec.eq_of_toNat_eq hz) + rw [ite_eq_right h] + exact shift_mask _ hb hn' + +end VG.Proof.Rc2.X86_64.Sse2 diff --git a/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2PiLookup.lean b/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2PiLookup.lean new file mode 100644 index 000000000..94eabfdd7 --- /dev/null +++ b/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2PiLookup.lean @@ -0,0 +1,48 @@ +import VerifiedGarbage.Proof.Rc2.X86_64.Sse2Steps +import VerifiedGarbage.Proof.Rc2.X86_64.Sse2Finish + +/-! # Verified constant-time SSE2 PITABLE lookup -/ + +namespace VG.Proof.Rc2.X86_64.Sse2 + +open VG VG.X86_64 VG.Impl.Rc2.X86_64 + +theorem piLookup_ok (s : State) + (hwrite : InRegions s.wr (s.gpr .r8 + BitVec.ofNat 64 64) 16) : + WP isa (.block Impl.Rc2.X86_64.Sse2.piLookup) s (fun s' => + s'.gpr .rax = (Spec.Rc2.pi ((s.gpr .rax).setWidth 8)).setWidth 64 ∧ + Keep [.rax, .rcx, .r10, .r11] s s') := by + have hread : InRegions (s.rd ++ s.wr) (s.gpr .r8 + BitVec.ofNat 64 64) 16 := by + obtain ⟨r, hr, hc⟩ := hwrite + exact ⟨r, List.mem_append_right _ hr, hc⟩ + rw [Impl.Rc2.X86_64.Sse2.piLookup, List.append_assoc, WP.block_append_iff] + obtain ⟨s₁, run₁, input₁, zero₁, idx₁, ones₁, eights₁, saved₁, keep₁⟩ := start_ok s .r8 hread + refine WP.of_runBlock ⟨s₁, run₁, ?_⟩ + rw [WP.block_append_iff, List.range_eq_range'] + have inv₁ : ScanInv ((s.gpr .rax).setWidth 8) 0 s₁ := + ⟨input₁, zero₁.trans (acc_zero _ _).symm, idx₁, ones₁, eights₁⟩ + apply WP.mono (piSteps_ok 32 0 (by decide) s₁ _ inv₁) + intro s₂ h₂ + rw [Impl.Rc2.X86_64.Sse2.finish, WP.block_append_iff] + obtain ⟨s₃, run₃, reduced₃, keep₃⟩ := reduceOr_ok s₂ + refine WP.of_runBlock ⟨s₃, run₃, ?_⟩ + have keep₂ : Keep [.rax, .r10] s₁ s₂ := h₂.2.1.weaken (by simp) + have keep₃' : Keep [.rax, .r10] s₂ s₃ := keep₃.keep.weaken (by simp) + have kept : Keep [.rax, .r10] s s₃ := (keep₁.trans keep₂).trans keep₃' + have ptr : s₃.gpr .r8 = s.gpr .r8 := kept.reg .r8 (by decide) + have wr₃ : InRegions s₃.wr (s₃.gpr .r8 + BitVec.ofNat 64 64) 16 := by + rw [kept.wr, ptr]; exact hwrite + have rd₃ : InRegions (s₃.rd ++ s₃.wr) (s₃.gpr .r8 + BitVec.ofNat 64 64) 8 := by + rw [kept.rd, kept.wr, ptr] + obtain ⟨r, hr, hc⟩ := hread + exact ⟨r, hr, by unfold Region.Contains at hc ⊢; omega⟩ + have saved₃ : s₃.xmm .xmm8 = s₃.mem.readW (s₃.gpr .r8 + BitVec.ofNat 64 64) 128 := by + rw [keep₃.xmm .xmm8 (by decide), h₂.2.2, saved₁, kept.mem, ptr] + obtain ⟨s₄, run₄, out₄, keep₄⟩ := finishTail_ok s₃ .r8 (by decide) rd₃ wr₃ saved₃ + refine WP.of_runBlock ⟨s₄, run₄, ?_⟩ + constructor + · rw [out₄, reduced₃, h₂.1.acc, reduce_acc, ite_eq_left ((s.gpr .rax).setWidth 8).isLt] + simp [piWord, Spec.Rc2.pi] + · exact (kept.trans (keep₄.weaken (by simp))).weaken (by simp) + +end VG.Proof.Rc2.X86_64.Sse2 diff --git a/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2Start.lean b/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2Start.lean new file mode 100644 index 000000000..a91a906ff --- /dev/null +++ b/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2Start.lean @@ -0,0 +1,48 @@ +import VerifiedGarbage.Proof.Rc2.X86_64.Sse2Vector + +/-! # Initialization of SSE2 RC2 lookup state -/ + +namespace VG.Proof.Rc2.X86_64.Sse2 + +open VG VG.X86_64 VG.X86_64.RegUpd VG.Impl.Rc2.X86_64 + +theorem start_ok (s : State) (scratch : Reg) + (hread : InRegions (s.rd ++ s.wr) (s.gpr scratch + BitVec.ofNat 64 64) 16) : + ∃ s', runBlock isa (Sse2.start scratch 255) s = some s' ∧ + s'.xmm .xmm0 = broadcast ((s.gpr .rax).setWidth 8) ∧ + s'.xmm .xmm1 = 0#128 ∧ s'.xmm .xmm2 = Sse2.indices 0 ∧ + s'.xmm .xmm6 = Sse2.ones ∧ s'.xmm .xmm7 = Sse2.eights ∧ + s'.xmm .xmm8 = s.mem.readW (s.gpr scratch + BitVec.ofNat 64 64) 128 ∧ + Keep [.rax, .r10] s s' := by + refine ⟨_, by + simp (config := {decide := true}) only [Sse2.start, Sse2.loadConst, + List.cons_append, List.nil_append, + runBlock_cons, runStep_some, runBlock_nil, exec, execAlu, readSrc, XOp.exec, + State.load128, State.ea, memOp, offset_nat, hread, ite_true, Option.bind_some, + Option.map_some, gpr_setReg, gpr_setXmm, gpr_arithFlags, + xmm_setReg, xmm_setXmm_self, xmm_setXmm_of_ne] + rfl, ?_⟩ + refine ⟨?_, ?_, ?_, ?_, ?_, ?_, ?_⟩ + · simp (config := {decide := true}) only [xmm_setXmm_self, xmm_setXmm_of_ne, xmm_setReg] + rw [show (255#32).signExtend 64 = (255 : BitVec 64) by decide, maskByte] + apply ext_word + intro i hi + rw [broadcast, word_ofWords _ hi] + exact broadcast_word _ i hi + · simp (config := {decide := true}) only [xmm_setXmm_self, xmm_setXmm_of_ne, xmm_setReg, + XBinOp.eval, BitVec.xor_self] + · simp (config := {decide := true}) only [xmm_setXmm_self, xmm_setXmm_of_ne, xmm_setReg] + · simp (config := {decide := true}) only [xmm_setXmm_self, xmm_setXmm_of_ne, xmm_setReg] + · simp only [xmm_setXmm_self] + exact movq_const _ + · simp (config := {decide := true}) only [xmm_setXmm_of_ne, xmm_setReg, + xmm_arithFlags, xmm_setXmm_self] + · constructor + · intro r hr + simp only [List.mem_cons, List.not_mem_nil, or_false, not_or] at hr + simp only [gpr_setXmm, gpr_setReg_of_ne _ _ hr.1, gpr_setReg_of_ne _ _ hr.2, gpr_arithFlags] + · simp only [mem_setXmm, mem_setReg, mem_arithFlags] + · simp only [rd_setXmm, rd_setReg, rd_arithFlags] + · simp only [wr_setXmm, wr_setReg, wr_arithFlags] + +end VG.Proof.Rc2.X86_64.Sse2 diff --git a/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2Steps.lean b/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2Steps.lean new file mode 100644 index 000000000..01d3709ae --- /dev/null +++ b/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2Steps.lean @@ -0,0 +1,65 @@ +import VerifiedGarbage.Proof.Rc2.X86_64.Sse2Start + +/-! # Composing eight-candidate PITABLE scans -/ + +namespace VG.Proof.Rc2.X86_64.Sse2 + +open VG VG.X86_64 VG.Impl.Rc2.X86_64 + +def piWord (i : Nat) : BitVec 16 := (Spec.Rc2.piTable.getD i 0).setWidth 16 + +structure ScanInv (x : Byte) (n : Nat) (s : State) : Prop where + input : s.xmm .xmm0 = broadcast x + acc : s.xmm .xmm1 = Sse2.acc piWord x.toNat n + indices : s.xmm .xmm2 = Impl.Rc2.X86_64.Sse2.indices n + ones : s.xmm .xmm6 = Impl.Rc2.X86_64.Sse2.ones + eights : s.xmm .xmm7 = Impl.Rc2.X86_64.Sse2.eights + +theorem piStep_ok (s : State) (x : Byte) (n : Nat) (hn : n < 32) (hinv : ScanInv x n s) : + WP isa (.block (Impl.Rc2.X86_64.Sse2.piStep n)) s (fun s' => + ScanInv x (n + 1) s' ∧ Keep [.r10] s s' ∧ s'.xmm .xmm8 = s.xmm .xmm8) := by + rw [Impl.Rc2.X86_64.Sse2.piStep, WP.block_append_iff] + obtain ⟨s₁, run₁, val₁, keep₁⟩ := loadConst_ok s .xmm4 (by decide) + (Impl.Rc2.X86_64.Sse2.piValues n) + refine WP.of_runBlock ⟨s₁, run₁, ?_⟩ + obtain ⟨s₂, run₂, val₂, idx₂, keep₂⟩ := select_ok s₁ + refine WP.of_runBlock ⟨s₂, run₂, ?_⟩ + refine ⟨?_, keep₁.keep.trans (keep₂.keep.weaken (by simp)), ?_⟩ + · constructor + · rw [keep₂.xmm .xmm0 (by decide), keep₁.xmm .xmm0 (by decide)] + exact hinv.input + · rw [val₂, keep₁.xmm .xmm1 (by decide), keep₁.xmm .xmm0 (by decide), + keep₁.xmm .xmm2 (by decide), keep₁.xmm .xmm6 (by decide), val₁, + hinv.acc, hinv.input, hinv.indices, hinv.ones] + apply acc_step piWord x n hn + intro j hj + exact word_ofWords _ hj + · rw [idx₂, keep₁.xmm .xmm2 (by decide), keep₁.xmm .xmm7 (by decide), + hinv.indices, hinv.eights] + exact indices_next n + · rw [keep₂.xmm .xmm6 (by decide), keep₁.xmm .xmm6 (by decide)] + exact hinv.ones + · rw [keep₂.xmm .xmm7 (by decide), keep₁.xmm .xmm7 (by decide)] + exact hinv.eights + · rw [keep₂.xmm .xmm8 (by decide), keep₁.xmm .xmm8 (by decide)] + +theorem piSteps_ok (count n : Nat) (hbound : n + count ≤ 32) + (s : State) (x : Byte) (hinv : ScanInv x n s) : + WP isa (.block ((List.range' n count).flatMap Impl.Rc2.X86_64.Sse2.piStep)) s + (fun s' => ScanInv x (n + count) s' ∧ Keep [.r10] s s' ∧ + s'.xmm .xmm8 = s.xmm .xmm8) := by + induction count generalizing n s with + | zero => + apply WP.block_nil + exact ⟨hinv, ⟨fun _ _ => rfl, rfl, rfl, rfl⟩, rfl⟩ + | succ count ih => + rw [List.range'_succ, List.flatMap_cons, WP.block_append_iff] + apply WP.mono (piStep_ok s x n (by omega) hinv) + intro s₁ h₁ + apply WP.mono (ih (n + 1) (by omega) s₁ h₁.1) + intro s₂ h₂ + refine ⟨?_, h₁.2.1.trans h₂.2.1, h₂.2.2.trans h₁.2.2⟩ + have he : n + 1 + count = n + (count + 1) := by omega + exact he ▸ h₂.1 + +end VG.Proof.Rc2.X86_64.Sse2 diff --git a/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2Vector.lean b/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2Vector.lean new file mode 100644 index 000000000..3bc0618b9 --- /dev/null +++ b/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2Vector.lean @@ -0,0 +1,128 @@ +import VerifiedGarbage.Proof.Rc2.X86_64.Sse2Exec + +/-! # Word-wise SSE2 lookup invariants -/ + +namespace VG.Proof.Rc2.X86_64.Sse2 + +open VG VG.X86_64 + +theorem word_por (a b : BitVec 128) (i : Nat) : + word (a ||| b) i = word a i ||| word b i := by + apply BitVec.eq_of_getLsbD_eq + intro j hj + simp only [getLsbD_word, BitVec.getLsbD_or, decide_eq_true hj, Bool.true_and] + +def broadcast (x : Byte) : BitVec 128 := ofWords fun _ => x.setWidth 16 + +theorem broadcast_word (x : Byte) (i : Nat) (hi : i < 8) : + word (shufDwords (XBinOp.eval .punpcklwd + (0#64 ++ x.setWidth 64) (0#64 ++ x.setWidth 64)) 0) i = x.setWidth 16 := by + have hd : dword (XBinOp.eval .punpcklwd + (0#64 ++ x.setWidth 64) (0#64 ++ x.setWidth 64)) 0 = + x.setWidth 16 ++ x.setWidth 16 := by + apply BitVec.eq_of_getLsbD_eq + intro j hj + simp only [dword, XBinOp.eval, ofWords, word, BitVec.getLsbD_extractLsb', + Nat.reduceMul, Nat.reduceAdd, Nat.reduceDiv, Nat.reduceMod, Nat.reduceEqDiff, + Nat.zero_add, ite_true, ite_false, decide_eq_true hj, Bool.true_and] + repeat rw [BitVec.getLsbD_append] + by_cases h : j < 16 <;> + simp (disch := omega) only [ite_eq_left, ite_eq_right, BitVec.getLsbD_extractLsb', + Nat.zero_add, decide_eq_true, Bool.true_and] + all_goals rw [BitVec.getLsbD_append] + all_goals simp (disch := omega) only [ite_eq_left, BitVec.getLsbD_setWidth, + decide_eq_true, Bool.true_and] + rw [shufDwords] + change word (ofDwords + (dword _ 0) (dword _ 0) (dword _ 0) (dword _ 0)) i = _ + rw [hd] + rcases (by omega : i = 0 ∨ i = 1 ∨ i = 2 ∨ i = 3 ∨ i = 4 ∨ i = 5 ∨ i = 6 ∨ i = 7) with + rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl <;> + rw [word_eq_dword _ hi] <;> + simp (disch := decide) only [Nat.reduceDiv, Nat.reduceMod, + dword_ofDwords_0, dword_ofDwords_1, dword_ofDwords_2, dword_ofDwords_3, + Nat.reduceMul, Nat.reduceSub, BitVec.extractLsb'_append_eq_of_add_le, + BitVec.extractLsb'_append_eq_of_le, BitVec.extractLsb'_eq_self] + + +def acc (f : Nat → BitVec 16) (x n : Nat) : BitVec 128 := + ofWords fun j => if x < 8 * n ∧ x % 8 = j then f x else 0#16 + +theorem acc_zero (f : Nat → BitVec 16) (x : Nat) : acc f x 0 = 0#128 := by + apply ext_word + intro j hj + rw [acc, word_ofWords _ hj] + simp [word] + +theorem indices_next (n : Nat) : + XBinOp.eval .paddw (Impl.Rc2.X86_64.Sse2.indices n) + Impl.Rc2.X86_64.Sse2.eights = Impl.Rc2.X86_64.Sse2.indices (n + 1) := by + apply ext_word + intro j hj + rw [word_paddw _ _ hj] + simp only [Impl.Rc2.X86_64.Sse2.indices, Impl.Rc2.X86_64.Sse2.eights, word_ofWords _ hj] + change BitVec.ofNat 16 (8 * n + j) + BitVec.ofNat 16 8 = _ + rw [← BitVec.ofNat_add] + congr 1 + omega + +theorem acc_step (f : Nat → BitVec 16) (x : Byte) (n : Nat) (hn : n < 32) + (v : BitVec 128) (hv : ∀ j < 8, word v j = f (8 * n + j)) : + acc f x.toNat n ||| selectValue (broadcast x) + (Impl.Rc2.X86_64.Sse2.indices n) Impl.Rc2.X86_64.Sse2.ones v = + acc f x.toNat (n + 1) := by + apply ext_word + intro j hj + rw [word_por, selectValue_word _ _ _ x (BitVec.ofNat 8 (8 * n + j)) j hj + (word_ofWords _ hj) (by + rw [Impl.Rc2.X86_64.Sse2.indices, word_ofWords _ hj] + apply BitVec.eq_of_toNat_eq + simp only [BitVec.toNat_setWidth, BitVec.toNat_ofNat] + omega)] + simp only [acc, word_ofWords _ hj, hv j hj] + have he : (x = BitVec.ofNat 8 (8 * n + j)) ↔ x.toNat = 8 * n + j := by + rw [← BitVec.toNat_inj, BitVec.toNat_ofNat, Nat.mod_eq_of_lt (by omega)] + by_cases h : x.toNat = 8 * n + j + · rw [ite_eq_left (he.mpr h), ite_eq_right (by omega), ite_eq_left (by omega), h] + exact BitVec.zero_or + · rw [ite_eq_right (mt he.mp h)] + change (if x.toNat < 8 * n ∧ x.toNat % 8 = j then f x.toNat else 0#16) ||| 0#16 = _ + rw [BitVec.or_zero] + have heq : (x.toNat < 8 * n ∧ x.toNat % 8 = j) ↔ + (x.toNat < 8 * (n + 1) ∧ x.toNat % 8 = j) := by omega + simp only [heq] + +def reduceValue (v : BitVec 128) : BitVec 128 := + let a := v ||| (v >>> 64) + let b := a ||| (a >>> 32) + b ||| (b >>> 16) + +theorem reduceValue_word (v : BitVec 128) : + word (reduceValue v) 0 = + word v 0 ||| word v 1 ||| word v 2 ||| word v 3 ||| + word v 4 ||| word v 5 ||| word v 6 ||| word v 7 := by + apply BitVec.eq_of_getLsbD_eq + intro j hj + simp only [reduceValue, getLsbD_word, BitVec.getLsbD_or, BitVec.getLsbD_ushiftRight, + decide_eq_true hj, Bool.true_and, Nat.mul_zero, Nat.zero_add] + simp only [Nat.reduceMul] + simp only [Nat.add_assoc, Nat.add_comm, Bool.or_comm, Bool.or_left_comm] + +theorem reduce_acc (f : Nat → BitVec 16) (x n : Nat) : + word (reduceValue (acc f x n)) 0 = if x < 8 * n then f x else 0#16 := by + rw [reduceValue_word] + simp only [acc, word_ofWords _ (by decide : 0 < 8), word_ofWords _ (by decide : 1 < 8), + word_ofWords _ (by decide : 2 < 8), word_ofWords _ (by decide : 3 < 8), + word_ofWords _ (by decide : 4 < 8), word_ofWords _ (by decide : 5 < 8), + word_ofWords _ (by decide : 6 < 8), word_ofWords _ (by decide : 7 < 8)] + by_cases h : x < 8 * n + · rw [ite_eq_left h] + rcases (by omega : x % 8 = 0 ∨ x % 8 = 1 ∨ x % 8 = 2 ∨ x % 8 = 3 ∨ + x % 8 = 4 ∨ x % 8 = 5 ∨ x % 8 = 6 ∨ x % 8 = 7) with + hm | hm | hm | hm | hm | hm | hm | hm <;> + simp only [h, hm, Nat.reduceEqDiff, ite_true, ite_false, true_and, and_false, + BitVec.or_zero, BitVec.zero_or] + · simp only [h, false_and, ite_false, BitVec.or_zero] + + +end VG.Proof.Rc2.X86_64.Sse2 diff --git a/src/asm/x86_64/rc2.rs b/src/asm/x86_64/rc2.rs index 42e856d5a..33755a4e8 100644 --- a/src/asm/x86_64/rc2.rs +++ b/src/asm/x86_64/rc2.rs @@ -100,7 +100,7 @@ pub(crate) unsafe extern "sysv64" fn vg_rc2_cbc_decrypt(schedule: *const [u8; 12 /// /// Contract: `VG.Spec.Rc2.expandKeyContract`. Constant time: only pointers, `key_len` and `effective_bits` may affect timing, not the key. /// -/// Baseline x86-64. PITABLE selection scans all 256 candidates in a fixed order. +/// Baseline x86-64 SSE2. PITABLE selection scans all 256 candidates in a fixed order, eight candidates per vector. /// /// # Safety /// @@ -142,4692 +142,1329 @@ pub(crate) unsafe extern "sysv64" fn vg_rc2_expand_key(key: *const u8, key_len: "sub r9, r13", "movzx ecx, BYTE PTR [r14+r9*1]", "add rax, rcx", + "movdqu xmm8, XMMWORD PTR [r8+64]", "and rax, 255", - "mov rcx, 0", - "mov r10, rax", - "xor r10, 0", - "sub r10, 1", - "sbb r10, r10", - "and r10, 217", - "or rcx, r10", - "mov r10, rax", - "xor r10, 1", - "sub r10, 1", - "sbb r10, r10", - "and r10, 120", - "or rcx, r10", - "mov r10, rax", - "xor r10, 2", - "sub r10, 1", - "sbb r10, r10", - "and r10, 249", - "or rcx, r10", - "mov r10, rax", - "xor r10, 3", - "sub r10, 1", - "sbb r10, r10", - "and r10, 196", - "or rcx, r10", - "mov r10, rax", - "xor r10, 4", - "sub r10, 1", - "sbb r10, r10", - "and r10, 25", - "or rcx, r10", - "mov r10, rax", - "xor r10, 5", - "sub r10, 1", - "sbb r10, r10", - "and r10, 221", - "or rcx, r10", - "mov r10, rax", - "xor r10, 6", - "sub r10, 1", - "sbb r10, r10", - "and r10, 181", - "or rcx, r10", - "mov r10, rax", - "xor r10, 7", - "sub r10, 1", - "sbb r10, r10", - "and r10, 237", - "or rcx, r10", - "mov r10, rax", - "xor r10, 8", - "sub r10, 1", - "sbb r10, r10", - "and r10, 40", - "or rcx, r10", - "mov r10, rax", - "xor r10, 9", - "sub r10, 1", - "sbb r10, r10", - "and r10, 233", - "or rcx, r10", - "mov r10, rax", - "xor r10, 10", - "sub r10, 1", - "sbb r10, r10", - "and r10, 253", - "or rcx, r10", - "mov r10, rax", - "xor r10, 11", - "sub r10, 1", - "sbb r10, r10", - "and r10, 121", - "or rcx, r10", - "mov r10, rax", - "xor r10, 12", - "sub r10, 1", - "sbb r10, r10", - "and r10, 74", - "or rcx, r10", - "mov r10, rax", - "xor r10, 13", - "sub r10, 1", - "sbb r10, r10", - "and r10, 160", - "or rcx, r10", - "mov r10, rax", - "xor r10, 14", - "sub r10, 1", - "sbb r10, r10", - "and r10, 216", - "or rcx, r10", - "mov r10, rax", - "xor r10, 15", - "sub r10, 1", - "sbb r10, r10", - "and r10, 157", - "or rcx, r10", - "mov r10, rax", - "xor r10, 16", - "sub r10, 1", - "sbb r10, r10", - "and r10, 198", - "or rcx, r10", - "mov r10, rax", - "xor r10, 17", - "sub r10, 1", - "sbb r10, r10", - "and r10, 126", - "or rcx, r10", - "mov r10, rax", - "xor r10, 18", - "sub r10, 1", - "sbb r10, r10", - "and r10, 55", - "or rcx, r10", - "mov r10, rax", - "xor r10, 19", - "sub r10, 1", - "sbb r10, r10", - "and r10, 131", - "or rcx, r10", - "mov r10, rax", - "xor r10, 20", - "sub r10, 1", - "sbb r10, r10", - "and r10, 43", - "or rcx, r10", - "mov r10, rax", - "xor r10, 21", - "sub r10, 1", - "sbb r10, r10", - "and r10, 118", - "or rcx, r10", - "mov r10, rax", - "xor r10, 22", - "sub r10, 1", - "sbb r10, r10", - "and r10, 83", - "or rcx, r10", - "mov r10, rax", - "xor r10, 23", - "sub r10, 1", - "sbb r10, r10", - "and r10, 142", - "or rcx, r10", - "mov r10, rax", - "xor r10, 24", - "sub r10, 1", - "sbb r10, r10", - "and r10, 98", - "or rcx, r10", - "mov r10, rax", - "xor r10, 25", - "sub r10, 1", - "sbb r10, r10", - "and r10, 76", - "or rcx, r10", - "mov r10, rax", - "xor r10, 26", - "sub r10, 1", - "sbb r10, r10", - "and r10, 100", - "or rcx, r10", - "mov r10, rax", - "xor r10, 27", - "sub r10, 1", - "sbb r10, r10", - "and r10, 136", - "or rcx, r10", - "mov r10, rax", - "xor r10, 28", - "sub r10, 1", - "sbb r10, r10", - "and r10, 68", - "or rcx, r10", - "mov r10, rax", - "xor r10, 29", - "sub r10, 1", - "sbb r10, r10", - "and r10, 139", - "or rcx, r10", - "mov r10, rax", - "xor r10, 30", - "sub r10, 1", - "sbb r10, r10", - "and r10, 251", - "or rcx, r10", - "mov r10, rax", - "xor r10, 31", - "sub r10, 1", - "sbb r10, r10", - "and r10, 162", - "or rcx, r10", - "mov r10, rax", - "xor r10, 32", - "sub r10, 1", - "sbb r10, r10", - "and r10, 23", - "or rcx, r10", - "mov r10, rax", - "xor r10, 33", - "sub r10, 1", - "sbb r10, r10", - "and r10, 154", - "or rcx, r10", - "mov r10, rax", - "xor r10, 34", - "sub r10, 1", - "sbb r10, r10", - "and r10, 89", - "or rcx, r10", - "mov r10, rax", - "xor r10, 35", - "sub r10, 1", - "sbb r10, r10", - "and r10, 245", - "or rcx, r10", - "mov r10, rax", - "xor r10, 36", - "sub r10, 1", - "sbb r10, r10", - "and r10, 135", - "or rcx, r10", - "mov r10, rax", - "xor r10, 37", - "sub r10, 1", - "sbb r10, r10", - "and r10, 179", - "or rcx, r10", - "mov r10, rax", - "xor r10, 38", - "sub r10, 1", - "sbb r10, r10", - "and r10, 79", - "or rcx, r10", - "mov r10, rax", - "xor r10, 39", - "sub r10, 1", - "sbb r10, r10", - "and r10, 19", - "or rcx, r10", - "mov r10, rax", - "xor r10, 40", - "sub r10, 1", - "sbb r10, r10", - "and r10, 97", - "or rcx, r10", - "mov r10, rax", - "xor r10, 41", - "sub r10, 1", - "sbb r10, r10", - "and r10, 69", - "or rcx, r10", - "mov r10, rax", - "xor r10, 42", - "sub r10, 1", - "sbb r10, r10", - "and r10, 109", - "or rcx, r10", - "mov r10, rax", - "xor r10, 43", - "sub r10, 1", - "sbb r10, r10", - "and r10, 141", - "or rcx, r10", - "mov r10, rax", - "xor r10, 44", - "sub r10, 1", - "sbb r10, r10", - "and r10, 9", - "or rcx, r10", - "mov r10, rax", - "xor r10, 45", - "sub r10, 1", - "sbb r10, r10", - "and r10, 129", - "or rcx, r10", - "mov r10, rax", - "xor r10, 46", - "sub r10, 1", - "sbb r10, r10", - "and r10, 125", - "or rcx, r10", - "mov r10, rax", - "xor r10, 47", - "sub r10, 1", - "sbb r10, r10", - "and r10, 50", - "or rcx, r10", - "mov r10, rax", - "xor r10, 48", - "sub r10, 1", - "sbb r10, r10", - "and r10, 189", - "or rcx, r10", - "mov r10, rax", - "xor r10, 49", - "sub r10, 1", - "sbb r10, r10", - "and r10, 143", - "or rcx, r10", - "mov r10, rax", - "xor r10, 50", - "sub r10, 1", - "sbb r10, r10", - "and r10, 64", - "or rcx, r10", - "mov r10, rax", - "xor r10, 51", - "sub r10, 1", - "sbb r10, r10", - "and r10, 235", - "or rcx, r10", - "mov r10, rax", - "xor r10, 52", - "sub r10, 1", - "sbb r10, r10", - "and r10, 134", - "or rcx, r10", - "mov r10, rax", - "xor r10, 53", - "sub r10, 1", - "sbb r10, r10", - "and r10, 183", - "or rcx, r10", - "mov r10, rax", - "xor r10, 54", - "sub r10, 1", - "sbb r10, r10", - "and r10, 123", - "or rcx, r10", - "mov r10, rax", - "xor r10, 55", - "sub r10, 1", - "sbb r10, r10", - "and r10, 11", - "or rcx, r10", - "mov r10, rax", - "xor r10, 56", - "sub r10, 1", - "sbb r10, r10", - "and r10, 240", - "or rcx, r10", - "mov r10, rax", - "xor r10, 57", - "sub r10, 1", - "sbb r10, r10", - "and r10, 149", - "or rcx, r10", - "mov r10, rax", - "xor r10, 58", - "sub r10, 1", - "sbb r10, r10", - "and r10, 33", - "or rcx, r10", - "mov r10, rax", - "xor r10, 59", - "sub r10, 1", - "sbb r10, r10", - "and r10, 34", - "or rcx, r10", - "mov r10, rax", - "xor r10, 60", - "sub r10, 1", - "sbb r10, r10", - "and r10, 92", - "or rcx, r10", - "mov r10, rax", - "xor r10, 61", - "sub r10, 1", - "sbb r10, r10", - "and r10, 107", - "or rcx, r10", - "mov r10, rax", - "xor r10, 62", - "sub r10, 1", - "sbb r10, r10", - "and r10, 78", - "or rcx, r10", - "mov r10, rax", - "xor r10, 63", - "sub r10, 1", - "sbb r10, r10", - "and r10, 130", - "or rcx, r10", - "mov r10, rax", - "xor r10, 64", - "sub r10, 1", - "sbb r10, r10", - "and r10, 84", - "or rcx, r10", - "mov r10, rax", - "xor r10, 65", - "sub r10, 1", - "sbb r10, r10", - "and r10, 214", - "or rcx, r10", - "mov r10, rax", - "xor r10, 66", - "sub r10, 1", - "sbb r10, r10", - "and r10, 101", - "or rcx, r10", - "mov r10, rax", - "xor r10, 67", - "sub r10, 1", - "sbb r10, r10", - "and r10, 147", - "or rcx, r10", - "mov r10, rax", - "xor r10, 68", - "sub r10, 1", - "sbb r10, r10", - "and r10, 206", - "or rcx, r10", - "mov r10, rax", - "xor r10, 69", - "sub r10, 1", - "sbb r10, r10", - "and r10, 96", - "or rcx, r10", - "mov r10, rax", - "xor r10, 70", - "sub r10, 1", - "sbb r10, r10", - "and r10, 178", - "or rcx, r10", - "mov r10, rax", - "xor r10, 71", - "sub r10, 1", - "sbb r10, r10", - "and r10, 28", - "or rcx, r10", - "mov r10, rax", - "xor r10, 72", - "sub r10, 1", - "sbb r10, r10", - "and r10, 115", - "or rcx, r10", - "mov r10, rax", - "xor r10, 73", - "sub r10, 1", - "sbb r10, r10", - "and r10, 86", - "or rcx, r10", - "mov r10, rax", - "xor r10, 74", - "sub r10, 1", - "sbb r10, r10", - "and r10, 192", - "or rcx, r10", - "mov r10, rax", - "xor r10, 75", - "sub r10, 1", - "sbb r10, r10", - "and r10, 20", - "or rcx, r10", - "mov r10, rax", - "xor r10, 76", - "sub r10, 1", - "sbb r10, r10", - "and r10, 167", - "or rcx, r10", - "mov r10, rax", - "xor r10, 77", - "sub r10, 1", - "sbb r10, r10", - "and r10, 140", - "or rcx, r10", - "mov r10, rax", - "xor r10, 78", - "sub r10, 1", - "sbb r10, r10", - "and r10, 241", - "or rcx, r10", - "mov r10, rax", - "xor r10, 79", - "sub r10, 1", - "sbb r10, r10", - "and r10, 220", - "or rcx, r10", - "mov r10, rax", - "xor r10, 80", - "sub r10, 1", - "sbb r10, r10", - "and r10, 18", - "or rcx, r10", - "mov r10, rax", - "xor r10, 81", - "sub r10, 1", - "sbb r10, r10", - "and r10, 117", - "or rcx, r10", - "mov r10, rax", - "xor r10, 82", - "sub r10, 1", - "sbb r10, r10", - "and r10, 202", - "or rcx, r10", - "mov r10, rax", - "xor r10, 83", - "sub r10, 1", - "sbb r10, r10", - "and r10, 31", - "or rcx, r10", - "mov r10, rax", - "xor r10, 84", - "sub r10, 1", - "sbb r10, r10", - "and r10, 59", - "or rcx, r10", - "mov r10, rax", - "xor r10, 85", - "sub r10, 1", - "sbb r10, r10", - "and r10, 190", - "or rcx, r10", - "mov r10, rax", - "xor r10, 86", - "sub r10, 1", - "sbb r10, r10", - "and r10, 228", - "or rcx, r10", - "mov r10, rax", - "xor r10, 87", - "sub r10, 1", - "sbb r10, r10", - "and r10, 209", - "or rcx, r10", - "mov r10, rax", - "xor r10, 88", - "sub r10, 1", - "sbb r10, r10", - "and r10, 66", - "or rcx, r10", - "mov r10, rax", - "xor r10, 89", - "sub r10, 1", - "sbb r10, r10", - "and r10, 61", - "or rcx, r10", - "mov r10, rax", - "xor r10, 90", - "sub r10, 1", - "sbb r10, r10", - "and r10, 212", - "or rcx, r10", - "mov r10, rax", - "xor r10, 91", - "sub r10, 1", - "sbb r10, r10", - "and r10, 48", - "or rcx, r10", - "mov r10, rax", - "xor r10, 92", - "sub r10, 1", - "sbb r10, r10", - "and r10, 163", - "or rcx, r10", - "mov r10, rax", - "xor r10, 93", - "sub r10, 1", - "sbb r10, r10", - "and r10, 60", - "or rcx, r10", - "mov r10, rax", - "xor r10, 94", - "sub r10, 1", - "sbb r10, r10", - "and r10, 182", - "or rcx, r10", - "mov r10, rax", - "xor r10, 95", - "sub r10, 1", - "sbb r10, r10", - "and r10, 38", - "or rcx, r10", - "mov r10, rax", - "xor r10, 96", - "sub r10, 1", - "sbb r10, r10", - "and r10, 111", - "or rcx, r10", - "mov r10, rax", - "xor r10, 97", - "sub r10, 1", - "sbb r10, r10", - "and r10, 191", - "or rcx, r10", - "mov r10, rax", - "xor r10, 98", - "sub r10, 1", - "sbb r10, r10", - "and r10, 14", - "or rcx, r10", - "mov r10, rax", - "xor r10, 99", - "sub r10, 1", - "sbb r10, r10", - "and r10, 218", - "or rcx, r10", - "mov r10, rax", - "xor r10, 100", - "sub r10, 1", - "sbb r10, r10", - "and r10, 70", - "or rcx, r10", - "mov r10, rax", - "xor r10, 101", - "sub r10, 1", - "sbb r10, r10", - "and r10, 105", - "or rcx, r10", - "mov r10, rax", - "xor r10, 102", - "sub r10, 1", - "sbb r10, r10", - "and r10, 7", - "or rcx, r10", - "mov r10, rax", - "xor r10, 103", - "sub r10, 1", - "sbb r10, r10", - "and r10, 87", - "or rcx, r10", - "mov r10, rax", - "xor r10, 104", - "sub r10, 1", - "sbb r10, r10", - "and r10, 39", - "or rcx, r10", - "mov r10, rax", - "xor r10, 105", - "sub r10, 1", - "sbb r10, r10", - "and r10, 242", - "or rcx, r10", - "mov r10, rax", - "xor r10, 106", - "sub r10, 1", - "sbb r10, r10", - "and r10, 29", - "or rcx, r10", - "mov r10, rax", - "xor r10, 107", - "sub r10, 1", - "sbb r10, r10", - "and r10, 155", - "or rcx, r10", - "mov r10, rax", - "xor r10, 108", - "sub r10, 1", - "sbb r10, r10", - "and r10, 188", - "or rcx, r10", - "mov r10, rax", - "xor r10, 109", - "sub r10, 1", - "sbb r10, r10", - "and r10, 148", - "or rcx, r10", - "mov r10, rax", - "xor r10, 110", - "sub r10, 1", - "sbb r10, r10", - "and r10, 67", - "or rcx, r10", - "mov r10, rax", - "xor r10, 111", - "sub r10, 1", - "sbb r10, r10", - "and r10, 3", - "or rcx, r10", - "mov r10, rax", - "xor r10, 112", - "sub r10, 1", - "sbb r10, r10", - "and r10, 248", - "or rcx, r10", - "mov r10, rax", - "xor r10, 113", - "sub r10, 1", - "sbb r10, r10", - "and r10, 17", - "or rcx, r10", - "mov r10, rax", - "xor r10, 114", - "sub r10, 1", - "sbb r10, r10", - "and r10, 199", - "or rcx, r10", - "mov r10, rax", - "xor r10, 115", - "sub r10, 1", - "sbb r10, r10", - "and r10, 246", - "or rcx, r10", - "mov r10, rax", - "xor r10, 116", - "sub r10, 1", - "sbb r10, r10", - "and r10, 144", - "or rcx, r10", - "mov r10, rax", - "xor r10, 117", - "sub r10, 1", - "sbb r10, r10", - "and r10, 239", - "or rcx, r10", - "mov r10, rax", - "xor r10, 118", - "sub r10, 1", - "sbb r10, r10", - "and r10, 62", - "or rcx, r10", - "mov r10, rax", - "xor r10, 119", - "sub r10, 1", - "sbb r10, r10", - "and r10, 231", - "or rcx, r10", - "mov r10, rax", - "xor r10, 120", - "sub r10, 1", - "sbb r10, r10", - "and r10, 6", - "or rcx, r10", - "mov r10, rax", - "xor r10, 121", - "sub r10, 1", - "sbb r10, r10", - "and r10, 195", - "or rcx, r10", - "mov r10, rax", - "xor r10, 122", - "sub r10, 1", - "sbb r10, r10", - "and r10, 213", - "or rcx, r10", - "mov r10, rax", - "xor r10, 123", - "sub r10, 1", - "sbb r10, r10", - "and r10, 47", - "or rcx, r10", - "mov r10, rax", - "xor r10, 124", - "sub r10, 1", - "sbb r10, r10", - "and r10, 200", - "or rcx, r10", - "mov r10, rax", - "xor r10, 125", - "sub r10, 1", - "sbb r10, r10", - "and r10, 102", - "or rcx, r10", - "mov r10, rax", - "xor r10, 126", - "sub r10, 1", - "sbb r10, r10", - "and r10, 30", - "or rcx, r10", - "mov r10, rax", - "xor r10, 127", - "sub r10, 1", - "sbb r10, r10", - "and r10, 215", - "or rcx, r10", - "mov r10, rax", - "xor r10, 128", - "sub r10, 1", - "sbb r10, r10", - "and r10, 8", - "or rcx, r10", - "mov r10, rax", - "xor r10, 129", - "sub r10, 1", - "sbb r10, r10", - "and r10, 232", - "or rcx, r10", - "mov r10, rax", - "xor r10, 130", - "sub r10, 1", - "sbb r10, r10", - "and r10, 234", - "or rcx, r10", - "mov r10, rax", - "xor r10, 131", - "sub r10, 1", - "sbb r10, r10", - "and r10, 222", - "or rcx, r10", - "mov r10, rax", - "xor r10, 132", - "sub r10, 1", - "sbb r10, r10", - "and r10, 128", - "or rcx, r10", - "mov r10, rax", - "xor r10, 133", - "sub r10, 1", - "sbb r10, r10", - "and r10, 82", - "or rcx, r10", - "mov r10, rax", - "xor r10, 134", - "sub r10, 1", - "sbb r10, r10", - "and r10, 238", - "or rcx, r10", - "mov r10, rax", - "xor r10, 135", - "sub r10, 1", - "sbb r10, r10", - "and r10, 247", - "or rcx, r10", - "mov r10, rax", - "xor r10, 136", - "sub r10, 1", - "sbb r10, r10", - "and r10, 132", - "or rcx, r10", - "mov r10, rax", - "xor r10, 137", - "sub r10, 1", - "sbb r10, r10", - "and r10, 170", - "or rcx, r10", - "mov r10, rax", - "xor r10, 138", - "sub r10, 1", - "sbb r10, r10", - "and r10, 114", - "or rcx, r10", - "mov r10, rax", - "xor r10, 139", - "sub r10, 1", - "sbb r10, r10", - "and r10, 172", - "or rcx, r10", - "mov r10, rax", - "xor r10, 140", - "sub r10, 1", - "sbb r10, r10", - "and r10, 53", - "or rcx, r10", - "mov r10, rax", - "xor r10, 141", - "sub r10, 1", - "sbb r10, r10", - "and r10, 77", - "or rcx, r10", - "mov r10, rax", - "xor r10, 142", - "sub r10, 1", - "sbb r10, r10", - "and r10, 106", - "or rcx, r10", - "mov r10, rax", - "xor r10, 143", - "sub r10, 1", - "sbb r10, r10", - "and r10, 42", - "or rcx, r10", - "mov r10, rax", - "xor r10, 144", - "sub r10, 1", - "sbb r10, r10", - "and r10, 150", - "or rcx, r10", - "mov r10, rax", - "xor r10, 145", - "sub r10, 1", - "sbb r10, r10", - "and r10, 26", - "or rcx, r10", - "mov r10, rax", - "xor r10, 146", - "sub r10, 1", - "sbb r10, r10", - "and r10, 210", - "or rcx, r10", - "mov r10, rax", - "xor r10, 147", - "sub r10, 1", - "sbb r10, r10", - "and r10, 113", - "or rcx, r10", - "mov r10, rax", - "xor r10, 148", - "sub r10, 1", - "sbb r10, r10", - "and r10, 90", - "or rcx, r10", - "mov r10, rax", - "xor r10, 149", - "sub r10, 1", - "sbb r10, r10", - "and r10, 21", - "or rcx, r10", - "mov r10, rax", - "xor r10, 150", - "sub r10, 1", - "sbb r10, r10", - "and r10, 73", - "or rcx, r10", - "mov r10, rax", - "xor r10, 151", - "sub r10, 1", - "sbb r10, r10", - "and r10, 116", - "or rcx, r10", - "mov r10, rax", - "xor r10, 152", - "sub r10, 1", - "sbb r10, r10", - "and r10, 75", - "or rcx, r10", - "mov r10, rax", - "xor r10, 153", - "sub r10, 1", - "sbb r10, r10", - "and r10, 159", - "or rcx, r10", - "mov r10, rax", - "xor r10, 154", - "sub r10, 1", - "sbb r10, r10", - "and r10, 208", - "or rcx, r10", - "mov r10, rax", - "xor r10, 155", - "sub r10, 1", - "sbb r10, r10", - "and r10, 94", - "or rcx, r10", - "mov r10, rax", - "xor r10, 156", - "sub r10, 1", - "sbb r10, r10", - "and r10, 4", - "or rcx, r10", - "mov r10, rax", - "xor r10, 157", - "sub r10, 1", - "sbb r10, r10", - "and r10, 24", - "or rcx, r10", - "mov r10, rax", - "xor r10, 158", - "sub r10, 1", - "sbb r10, r10", - "and r10, 164", - "or rcx, r10", - "mov r10, rax", - "xor r10, 159", - "sub r10, 1", - "sbb r10, r10", - "and r10, 236", - "or rcx, r10", - "mov r10, rax", - "xor r10, 160", - "sub r10, 1", - "sbb r10, r10", - "and r10, 194", - "or rcx, r10", - "mov r10, rax", - "xor r10, 161", - "sub r10, 1", - "sbb r10, r10", - "and r10, 224", - "or rcx, r10", - "mov r10, rax", - "xor r10, 162", - "sub r10, 1", - "sbb r10, r10", - "and r10, 65", - "or rcx, r10", - "mov r10, rax", - "xor r10, 163", - "sub r10, 1", - "sbb r10, r10", - "and r10, 110", - "or rcx, r10", - "mov r10, rax", - "xor r10, 164", - "sub r10, 1", - "sbb r10, r10", - "and r10, 15", - "or rcx, r10", - "mov r10, rax", - "xor r10, 165", - "sub r10, 1", - "sbb r10, r10", - "and r10, 81", - "or rcx, r10", - "mov r10, rax", - "xor r10, 166", - "sub r10, 1", - "sbb r10, r10", - "and r10, 203", - "or rcx, r10", - "mov r10, rax", - "xor r10, 167", - "sub r10, 1", - "sbb r10, r10", - "and r10, 204", - "or rcx, r10", - "mov r10, rax", - "xor r10, 168", - "sub r10, 1", - "sbb r10, r10", - "and r10, 36", - "or rcx, r10", - "mov r10, rax", - "xor r10, 169", - "sub r10, 1", - "sbb r10, r10", - "and r10, 145", - "or rcx, r10", - "mov r10, rax", - "xor r10, 170", - "sub r10, 1", - "sbb r10, r10", - "and r10, 175", - "or rcx, r10", - "mov r10, rax", - "xor r10, 171", - "sub r10, 1", - "sbb r10, r10", - "and r10, 80", - "or rcx, r10", - "mov r10, rax", - "xor r10, 172", - "sub r10, 1", - "sbb r10, r10", - "and r10, 161", - "or rcx, r10", - "mov r10, rax", - "xor r10, 173", - "sub r10, 1", - "sbb r10, r10", - "and r10, 244", - "or rcx, r10", - "mov r10, rax", - "xor r10, 174", - "sub r10, 1", - "sbb r10, r10", - "and r10, 112", - "or rcx, r10", - "mov r10, rax", - "xor r10, 175", - "sub r10, 1", - "sbb r10, r10", - "and r10, 57", - "or rcx, r10", - "mov r10, rax", - "xor r10, 176", - "sub r10, 1", - "sbb r10, r10", - "and r10, 153", - "or rcx, r10", - "mov r10, rax", - "xor r10, 177", - "sub r10, 1", - "sbb r10, r10", - "and r10, 124", - "or rcx, r10", - "mov r10, rax", - "xor r10, 178", - "sub r10, 1", - "sbb r10, r10", - "and r10, 58", - "or rcx, r10", - "mov r10, rax", - "xor r10, 179", - "sub r10, 1", - "sbb r10, r10", - "and r10, 133", - "or rcx, r10", - "mov r10, rax", - "xor r10, 180", - "sub r10, 1", - "sbb r10, r10", - "and r10, 35", - "or rcx, r10", - "mov r10, rax", - "xor r10, 181", - "sub r10, 1", - "sbb r10, r10", - "and r10, 184", - "or rcx, r10", - "mov r10, rax", - "xor r10, 182", - "sub r10, 1", - "sbb r10, r10", - "and r10, 180", - "or rcx, r10", - "mov r10, rax", - "xor r10, 183", - "sub r10, 1", - "sbb r10, r10", - "and r10, 122", - "or rcx, r10", - "mov r10, rax", - "xor r10, 184", - "sub r10, 1", - "sbb r10, r10", - "and r10, 252", - "or rcx, r10", - "mov r10, rax", - "xor r10, 185", - "sub r10, 1", - "sbb r10, r10", - "and r10, 2", - "or rcx, r10", - "mov r10, rax", - "xor r10, 186", - "sub r10, 1", - "sbb r10, r10", - "and r10, 54", - "or rcx, r10", - "mov r10, rax", - "xor r10, 187", - "sub r10, 1", - "sbb r10, r10", - "and r10, 91", - "or rcx, r10", - "mov r10, rax", - "xor r10, 188", - "sub r10, 1", - "sbb r10, r10", - "and r10, 37", - "or rcx, r10", - "mov r10, rax", - "xor r10, 189", - "sub r10, 1", - "sbb r10, r10", - "and r10, 85", - "or rcx, r10", - "mov r10, rax", - "xor r10, 190", - "sub r10, 1", - "sbb r10, r10", - "and r10, 151", - "or rcx, r10", - "mov r10, rax", - "xor r10, 191", - "sub r10, 1", - "sbb r10, r10", - "and r10, 49", - "or rcx, r10", - "mov r10, rax", - "xor r10, 192", - "sub r10, 1", - "sbb r10, r10", - "and r10, 45", - "or rcx, r10", - "mov r10, rax", - "xor r10, 193", - "sub r10, 1", - "sbb r10, r10", - "and r10, 93", - "or rcx, r10", - "mov r10, rax", - "xor r10, 194", - "sub r10, 1", - "sbb r10, r10", - "and r10, 250", - "or rcx, r10", - "mov r10, rax", - "xor r10, 195", - "sub r10, 1", - "sbb r10, r10", - "and r10, 152", - "or rcx, r10", - "mov r10, rax", - "xor r10, 196", - "sub r10, 1", - "sbb r10, r10", - "and r10, 227", - "or rcx, r10", - "mov r10, rax", - "xor r10, 197", - "sub r10, 1", - "sbb r10, r10", - "and r10, 138", - "or rcx, r10", - "mov r10, rax", - "xor r10, 198", - "sub r10, 1", - "sbb r10, r10", - "and r10, 146", - "or rcx, r10", - "mov r10, rax", - "xor r10, 199", - "sub r10, 1", - "sbb r10, r10", - "and r10, 174", - "or rcx, r10", - "mov r10, rax", - "xor r10, 200", - "sub r10, 1", - "sbb r10, r10", - "and r10, 5", - "or rcx, r10", - "mov r10, rax", - "xor r10, 201", - "sub r10, 1", - "sbb r10, r10", - "and r10, 223", - "or rcx, r10", - "mov r10, rax", - "xor r10, 202", - "sub r10, 1", - "sbb r10, r10", - "and r10, 41", - "or rcx, r10", - "mov r10, rax", - "xor r10, 203", - "sub r10, 1", - "sbb r10, r10", - "and r10, 16", - "or rcx, r10", - "mov r10, rax", - "xor r10, 204", - "sub r10, 1", - "sbb r10, r10", - "and r10, 103", - "or rcx, r10", - "mov r10, rax", - "xor r10, 205", - "sub r10, 1", - "sbb r10, r10", - "and r10, 108", - "or rcx, r10", - "mov r10, rax", - "xor r10, 206", - "sub r10, 1", - "sbb r10, r10", - "and r10, 186", - "or rcx, r10", - "mov r10, rax", - "xor r10, 207", - "sub r10, 1", - "sbb r10, r10", - "and r10, 201", - "or rcx, r10", - "mov r10, rax", - "xor r10, 208", - "sub r10, 1", - "sbb r10, r10", - "and r10, 211", - "or rcx, r10", - "mov r10, rax", - "xor r10, 209", - "sub r10, 1", - "sbb r10, r10", - "and r10, 0", - "or rcx, r10", - "mov r10, rax", - "xor r10, 210", - "sub r10, 1", - "sbb r10, r10", - "and r10, 230", - "or rcx, r10", - "mov r10, rax", - "xor r10, 211", - "sub r10, 1", - "sbb r10, r10", - "and r10, 207", - "or rcx, r10", - "mov r10, rax", - "xor r10, 212", - "sub r10, 1", - "sbb r10, r10", - "and r10, 225", - "or rcx, r10", - "mov r10, rax", - "xor r10, 213", - "sub r10, 1", - "sbb r10, r10", - "and r10, 158", - "or rcx, r10", - "mov r10, rax", - "xor r10, 214", - "sub r10, 1", - "sbb r10, r10", - "and r10, 168", - "or rcx, r10", - "mov r10, rax", - "xor r10, 215", - "sub r10, 1", - "sbb r10, r10", - "and r10, 44", - "or rcx, r10", - "mov r10, rax", - "xor r10, 216", - "sub r10, 1", - "sbb r10, r10", - "and r10, 99", - "or rcx, r10", - "mov r10, rax", - "xor r10, 217", - "sub r10, 1", - "sbb r10, r10", - "and r10, 22", - "or rcx, r10", - "mov r10, rax", - "xor r10, 218", - "sub r10, 1", - "sbb r10, r10", - "and r10, 1", - "or rcx, r10", - "mov r10, rax", - "xor r10, 219", - "sub r10, 1", - "sbb r10, r10", - "and r10, 63", - "or rcx, r10", - "mov r10, rax", - "xor r10, 220", - "sub r10, 1", - "sbb r10, r10", - "and r10, 88", - "or rcx, r10", - "mov r10, rax", - "xor r10, 221", - "sub r10, 1", - "sbb r10, r10", - "and r10, 226", - "or rcx, r10", - "mov r10, rax", - "xor r10, 222", - "sub r10, 1", - "sbb r10, r10", - "and r10, 137", - "or rcx, r10", - "mov r10, rax", - "xor r10, 223", - "sub r10, 1", - "sbb r10, r10", - "and r10, 169", - "or rcx, r10", - "mov r10, rax", - "xor r10, 224", - "sub r10, 1", - "sbb r10, r10", - "and r10, 13", - "or rcx, r10", - "mov r10, rax", - "xor r10, 225", - "sub r10, 1", - "sbb r10, r10", - "and r10, 56", - "or rcx, r10", - "mov r10, rax", - "xor r10, 226", - "sub r10, 1", - "sbb r10, r10", - "and r10, 52", - "or rcx, r10", - "mov r10, rax", - "xor r10, 227", - "sub r10, 1", - "sbb r10, r10", - "and r10, 27", - "or rcx, r10", - "mov r10, rax", - "xor r10, 228", - "sub r10, 1", - "sbb r10, r10", - "and r10, 171", - "or rcx, r10", - "mov r10, rax", - "xor r10, 229", - "sub r10, 1", - "sbb r10, r10", - "and r10, 51", - "or rcx, r10", - "mov r10, rax", - "xor r10, 230", - "sub r10, 1", - "sbb r10, r10", - "and r10, 255", - "or rcx, r10", - "mov r10, rax", - "xor r10, 231", - "sub r10, 1", - "sbb r10, r10", - "and r10, 176", - "or rcx, r10", - "mov r10, rax", - "xor r10, 232", - "sub r10, 1", - "sbb r10, r10", - "and r10, 187", - "or rcx, r10", - "mov r10, rax", - "xor r10, 233", - "sub r10, 1", - "sbb r10, r10", - "and r10, 72", - "or rcx, r10", - "mov r10, rax", - "xor r10, 234", - "sub r10, 1", - "sbb r10, r10", - "and r10, 12", - "or rcx, r10", - "mov r10, rax", - "xor r10, 235", - "sub r10, 1", - "sbb r10, r10", - "and r10, 95", - "or rcx, r10", - "mov r10, rax", - "xor r10, 236", - "sub r10, 1", - "sbb r10, r10", - "and r10, 185", - "or rcx, r10", - "mov r10, rax", - "xor r10, 237", - "sub r10, 1", - "sbb r10, r10", - "and r10, 177", - "or rcx, r10", - "mov r10, rax", - "xor r10, 238", - "sub r10, 1", - "sbb r10, r10", - "and r10, 205", - "or rcx, r10", - "mov r10, rax", - "xor r10, 239", - "sub r10, 1", - "sbb r10, r10", - "and r10, 46", - "or rcx, r10", - "mov r10, rax", - "xor r10, 240", - "sub r10, 1", - "sbb r10, r10", - "and r10, 197", - "or rcx, r10", - "mov r10, rax", - "xor r10, 241", - "sub r10, 1", - "sbb r10, r10", - "and r10, 243", - "or rcx, r10", - "mov r10, rax", - "xor r10, 242", - "sub r10, 1", - "sbb r10, r10", - "and r10, 219", - "or rcx, r10", - "mov r10, rax", - "xor r10, 243", - "sub r10, 1", - "sbb r10, r10", - "and r10, 71", - "or rcx, r10", - "mov r10, rax", - "xor r10, 244", - "sub r10, 1", - "sbb r10, r10", - "and r10, 229", - "or rcx, r10", - "mov r10, rax", - "xor r10, 245", - "sub r10, 1", - "sbb r10, r10", - "and r10, 165", - "or rcx, r10", - "mov r10, rax", - "xor r10, 246", - "sub r10, 1", - "sbb r10, r10", - "and r10, 156", - "or rcx, r10", - "mov r10, rax", - "xor r10, 247", - "sub r10, 1", - "sbb r10, r10", - "and r10, 119", - "or rcx, r10", - "mov r10, rax", - "xor r10, 248", - "sub r10, 1", - "sbb r10, r10", - "and r10, 10", - "or rcx, r10", - "mov r10, rax", - "xor r10, 249", - "sub r10, 1", - "sbb r10, r10", - "and r10, 166", - "or rcx, r10", - "mov r10, rax", - "xor r10, 250", - "sub r10, 1", - "sbb r10, r10", - "and r10, 32", - "or rcx, r10", - "mov r10, rax", - "xor r10, 251", - "sub r10, 1", - "sbb r10, r10", - "and r10, 104", - "or rcx, r10", - "mov r10, rax", - "xor r10, 252", - "sub r10, 1", - "sbb r10, r10", - "and r10, 254", - "or rcx, r10", - "mov r10, rax", - "xor r10, 253", - "sub r10, 1", - "sbb r10, r10", - "and r10, 127", - "or rcx, r10", - "mov r10, rax", - "xor r10, 254", - "sub r10, 1", - "sbb r10, r10", - "and r10, 193", - "or rcx, r10", - "mov r10, rax", - "xor r10, 255", - "sub r10, 1", - "sbb r10, r10", - "and r10, 173", - "or rcx, r10", - "mov rax, rcx", - "mov BYTE PTR [r14+rbx*1], al", - "add rbx, 1", - "cmp rbx, 128", - "jne 23b", - "22:", - "mov rbp, r15", - "add rbp, 7", - "shr rbp, 3", - "mov rbx, 128", - "sub rbx, rbp", - "mov r9, r15", - "and r9, 7", - "mov rdx, 255", - "cmp r9, 1", - "je 24f", - "jmp 25f", - "24:", - "mov rdx, 1", - "25:", - "cmp r9, 2", - "je 26f", - "jmp 27f", - "26:", - "mov rdx, 3", - "27:", - "cmp r9, 3", - "je 28f", - "jmp 29f", - "28:", - "mov rdx, 7", - "29:", - "cmp r9, 4", - "je 210f", - "jmp 211f", - "210:", - "mov rdx, 15", - "211:", - "cmp r9, 5", - "je 212f", - "jmp 213f", - "212:", - "mov rdx, 31", - "213:", - "cmp r9, 6", - "je 214f", - "jmp 215f", - "214:", - "mov rdx, 63", - "215:", - "cmp r9, 7", - "je 216f", - "jmp 217f", - "216:", - "mov rdx, 127", - "217:", - "movzx eax, BYTE PTR [r14+rbx*1]", - "and rax, rdx", - "and rax, 255", - "mov rcx, 0", - "mov r10, rax", - "xor r10, 0", - "sub r10, 1", - "sbb r10, r10", - "and r10, 217", - "or rcx, r10", - "mov r10, rax", - "xor r10, 1", - "sub r10, 1", - "sbb r10, r10", - "and r10, 120", - "or rcx, r10", - "mov r10, rax", - "xor r10, 2", - "sub r10, 1", - "sbb r10, r10", - "and r10, 249", - "or rcx, r10", - "mov r10, rax", - "xor r10, 3", - "sub r10, 1", - "sbb r10, r10", - "and r10, 196", - "or rcx, r10", - "mov r10, rax", - "xor r10, 4", - "sub r10, 1", - "sbb r10, r10", - "and r10, 25", - "or rcx, r10", - "mov r10, rax", - "xor r10, 5", - "sub r10, 1", - "sbb r10, r10", - "and r10, 221", - "or rcx, r10", - "mov r10, rax", - "xor r10, 6", - "sub r10, 1", - "sbb r10, r10", - "and r10, 181", - "or rcx, r10", - "mov r10, rax", - "xor r10, 7", - "sub r10, 1", - "sbb r10, r10", - "and r10, 237", - "or rcx, r10", - "mov r10, rax", - "xor r10, 8", - "sub r10, 1", - "sbb r10, r10", - "and r10, 40", - "or rcx, r10", - "mov r10, rax", - "xor r10, 9", - "sub r10, 1", - "sbb r10, r10", - "and r10, 233", - "or rcx, r10", - "mov r10, rax", - "xor r10, 10", - "sub r10, 1", - "sbb r10, r10", - "and r10, 253", - "or rcx, r10", - "mov r10, rax", - "xor r10, 11", - "sub r10, 1", - "sbb r10, r10", - "and r10, 121", - "or rcx, r10", - "mov r10, rax", - "xor r10, 12", - "sub r10, 1", - "sbb r10, r10", - "and r10, 74", - "or rcx, r10", - "mov r10, rax", - "xor r10, 13", - "sub r10, 1", - "sbb r10, r10", - "and r10, 160", - "or rcx, r10", - "mov r10, rax", - "xor r10, 14", - "sub r10, 1", - "sbb r10, r10", - "and r10, 216", - "or rcx, r10", - "mov r10, rax", - "xor r10, 15", - "sub r10, 1", - "sbb r10, r10", - "and r10, 157", - "or rcx, r10", - "mov r10, rax", - "xor r10, 16", - "sub r10, 1", - "sbb r10, r10", - "and r10, 198", - "or rcx, r10", - "mov r10, rax", - "xor r10, 17", - "sub r10, 1", - "sbb r10, r10", - "and r10, 126", - "or rcx, r10", - "mov r10, rax", - "xor r10, 18", - "sub r10, 1", - "sbb r10, r10", - "and r10, 55", - "or rcx, r10", - "mov r10, rax", - "xor r10, 19", - "sub r10, 1", - "sbb r10, r10", - "and r10, 131", - "or rcx, r10", - "mov r10, rax", - "xor r10, 20", - "sub r10, 1", - "sbb r10, r10", - "and r10, 43", - "or rcx, r10", - "mov r10, rax", - "xor r10, 21", - "sub r10, 1", - "sbb r10, r10", - "and r10, 118", - "or rcx, r10", - "mov r10, rax", - "xor r10, 22", - "sub r10, 1", - "sbb r10, r10", - "and r10, 83", - "or rcx, r10", - "mov r10, rax", - "xor r10, 23", - "sub r10, 1", - "sbb r10, r10", - "and r10, 142", - "or rcx, r10", - "mov r10, rax", - "xor r10, 24", - "sub r10, 1", - "sbb r10, r10", - "and r10, 98", - "or rcx, r10", - "mov r10, rax", - "xor r10, 25", - "sub r10, 1", - "sbb r10, r10", - "and r10, 76", - "or rcx, r10", - "mov r10, rax", - "xor r10, 26", - "sub r10, 1", - "sbb r10, r10", - "and r10, 100", - "or rcx, r10", - "mov r10, rax", - "xor r10, 27", - "sub r10, 1", - "sbb r10, r10", - "and r10, 136", - "or rcx, r10", - "mov r10, rax", - "xor r10, 28", - "sub r10, 1", - "sbb r10, r10", - "and r10, 68", - "or rcx, r10", - "mov r10, rax", - "xor r10, 29", - "sub r10, 1", - "sbb r10, r10", - "and r10, 139", - "or rcx, r10", - "mov r10, rax", - "xor r10, 30", - "sub r10, 1", - "sbb r10, r10", - "and r10, 251", - "or rcx, r10", - "mov r10, rax", - "xor r10, 31", - "sub r10, 1", - "sbb r10, r10", - "and r10, 162", - "or rcx, r10", - "mov r10, rax", - "xor r10, 32", - "sub r10, 1", - "sbb r10, r10", - "and r10, 23", - "or rcx, r10", - "mov r10, rax", - "xor r10, 33", - "sub r10, 1", - "sbb r10, r10", - "and r10, 154", - "or rcx, r10", - "mov r10, rax", - "xor r10, 34", - "sub r10, 1", - "sbb r10, r10", - "and r10, 89", - "or rcx, r10", - "mov r10, rax", - "xor r10, 35", - "sub r10, 1", - "sbb r10, r10", - "and r10, 245", - "or rcx, r10", - "mov r10, rax", - "xor r10, 36", - "sub r10, 1", - "sbb r10, r10", - "and r10, 135", - "or rcx, r10", - "mov r10, rax", - "xor r10, 37", - "sub r10, 1", - "sbb r10, r10", - "and r10, 179", - "or rcx, r10", - "mov r10, rax", - "xor r10, 38", - "sub r10, 1", - "sbb r10, r10", - "and r10, 79", - "or rcx, r10", - "mov r10, rax", - "xor r10, 39", - "sub r10, 1", - "sbb r10, r10", - "and r10, 19", - "or rcx, r10", - "mov r10, rax", - "xor r10, 40", - "sub r10, 1", - "sbb r10, r10", - "and r10, 97", - "or rcx, r10", - "mov r10, rax", - "xor r10, 41", - "sub r10, 1", - "sbb r10, r10", - "and r10, 69", - "or rcx, r10", - "mov r10, rax", - "xor r10, 42", - "sub r10, 1", - "sbb r10, r10", - "and r10, 109", - "or rcx, r10", - "mov r10, rax", - "xor r10, 43", - "sub r10, 1", - "sbb r10, r10", - "and r10, 141", - "or rcx, r10", - "mov r10, rax", - "xor r10, 44", - "sub r10, 1", - "sbb r10, r10", - "and r10, 9", - "or rcx, r10", - "mov r10, rax", - "xor r10, 45", - "sub r10, 1", - "sbb r10, r10", - "and r10, 129", - "or rcx, r10", - "mov r10, rax", - "xor r10, 46", - "sub r10, 1", - "sbb r10, r10", - "and r10, 125", - "or rcx, r10", - "mov r10, rax", - "xor r10, 47", - "sub r10, 1", - "sbb r10, r10", - "and r10, 50", - "or rcx, r10", - "mov r10, rax", - "xor r10, 48", - "sub r10, 1", - "sbb r10, r10", - "and r10, 189", - "or rcx, r10", - "mov r10, rax", - "xor r10, 49", - "sub r10, 1", - "sbb r10, r10", - "and r10, 143", - "or rcx, r10", - "mov r10, rax", - "xor r10, 50", - "sub r10, 1", - "sbb r10, r10", - "and r10, 64", - "or rcx, r10", - "mov r10, rax", - "xor r10, 51", - "sub r10, 1", - "sbb r10, r10", - "and r10, 235", - "or rcx, r10", - "mov r10, rax", - "xor r10, 52", - "sub r10, 1", - "sbb r10, r10", - "and r10, 134", - "or rcx, r10", - "mov r10, rax", - "xor r10, 53", - "sub r10, 1", - "sbb r10, r10", - "and r10, 183", - "or rcx, r10", - "mov r10, rax", - "xor r10, 54", - "sub r10, 1", - "sbb r10, r10", - "and r10, 123", - "or rcx, r10", - "mov r10, rax", - "xor r10, 55", - "sub r10, 1", - "sbb r10, r10", - "and r10, 11", - "or rcx, r10", - "mov r10, rax", - "xor r10, 56", - "sub r10, 1", - "sbb r10, r10", - "and r10, 240", - "or rcx, r10", - "mov r10, rax", - "xor r10, 57", - "sub r10, 1", - "sbb r10, r10", - "and r10, 149", - "or rcx, r10", - "mov r10, rax", - "xor r10, 58", - "sub r10, 1", - "sbb r10, r10", - "and r10, 33", - "or rcx, r10", - "mov r10, rax", - "xor r10, 59", - "sub r10, 1", - "sbb r10, r10", - "and r10, 34", - "or rcx, r10", - "mov r10, rax", - "xor r10, 60", - "sub r10, 1", - "sbb r10, r10", - "and r10, 92", - "or rcx, r10", - "mov r10, rax", - "xor r10, 61", - "sub r10, 1", - "sbb r10, r10", - "and r10, 107", - "or rcx, r10", - "mov r10, rax", - "xor r10, 62", - "sub r10, 1", - "sbb r10, r10", - "and r10, 78", - "or rcx, r10", - "mov r10, rax", - "xor r10, 63", - "sub r10, 1", - "sbb r10, r10", - "and r10, 130", - "or rcx, r10", - "mov r10, rax", - "xor r10, 64", - "sub r10, 1", - "sbb r10, r10", - "and r10, 84", - "or rcx, r10", - "mov r10, rax", - "xor r10, 65", - "sub r10, 1", - "sbb r10, r10", - "and r10, 214", - "or rcx, r10", - "mov r10, rax", - "xor r10, 66", - "sub r10, 1", - "sbb r10, r10", - "and r10, 101", - "or rcx, r10", - "mov r10, rax", - "xor r10, 67", - "sub r10, 1", - "sbb r10, r10", - "and r10, 147", - "or rcx, r10", - "mov r10, rax", - "xor r10, 68", - "sub r10, 1", - "sbb r10, r10", - "and r10, 206", - "or rcx, r10", - "mov r10, rax", - "xor r10, 69", - "sub r10, 1", - "sbb r10, r10", - "and r10, 96", - "or rcx, r10", - "mov r10, rax", - "xor r10, 70", - "sub r10, 1", - "sbb r10, r10", - "and r10, 178", - "or rcx, r10", - "mov r10, rax", - "xor r10, 71", - "sub r10, 1", - "sbb r10, r10", - "and r10, 28", - "or rcx, r10", - "mov r10, rax", - "xor r10, 72", - "sub r10, 1", - "sbb r10, r10", - "and r10, 115", - "or rcx, r10", - "mov r10, rax", - "xor r10, 73", - "sub r10, 1", - "sbb r10, r10", - "and r10, 86", - "or rcx, r10", - "mov r10, rax", - "xor r10, 74", - "sub r10, 1", - "sbb r10, r10", - "and r10, 192", - "or rcx, r10", - "mov r10, rax", - "xor r10, 75", - "sub r10, 1", - "sbb r10, r10", - "and r10, 20", - "or rcx, r10", - "mov r10, rax", - "xor r10, 76", - "sub r10, 1", - "sbb r10, r10", - "and r10, 167", - "or rcx, r10", - "mov r10, rax", - "xor r10, 77", - "sub r10, 1", - "sbb r10, r10", - "and r10, 140", - "or rcx, r10", - "mov r10, rax", - "xor r10, 78", - "sub r10, 1", - "sbb r10, r10", - "and r10, 241", - "or rcx, r10", - "mov r10, rax", - "xor r10, 79", - "sub r10, 1", - "sbb r10, r10", - "and r10, 220", - "or rcx, r10", - "mov r10, rax", - "xor r10, 80", - "sub r10, 1", - "sbb r10, r10", - "and r10, 18", - "or rcx, r10", - "mov r10, rax", - "xor r10, 81", - "sub r10, 1", - "sbb r10, r10", - "and r10, 117", - "or rcx, r10", - "mov r10, rax", - "xor r10, 82", - "sub r10, 1", - "sbb r10, r10", - "and r10, 202", - "or rcx, r10", - "mov r10, rax", - "xor r10, 83", - "sub r10, 1", - "sbb r10, r10", - "and r10, 31", - "or rcx, r10", - "mov r10, rax", - "xor r10, 84", - "sub r10, 1", - "sbb r10, r10", - "and r10, 59", - "or rcx, r10", - "mov r10, rax", - "xor r10, 85", - "sub r10, 1", - "sbb r10, r10", - "and r10, 190", - "or rcx, r10", - "mov r10, rax", - "xor r10, 86", - "sub r10, 1", - "sbb r10, r10", - "and r10, 228", - "or rcx, r10", - "mov r10, rax", - "xor r10, 87", - "sub r10, 1", - "sbb r10, r10", - "and r10, 209", - "or rcx, r10", - "mov r10, rax", - "xor r10, 88", - "sub r10, 1", - "sbb r10, r10", - "and r10, 66", - "or rcx, r10", - "mov r10, rax", - "xor r10, 89", - "sub r10, 1", - "sbb r10, r10", - "and r10, 61", - "or rcx, r10", - "mov r10, rax", - "xor r10, 90", - "sub r10, 1", - "sbb r10, r10", - "and r10, 212", - "or rcx, r10", - "mov r10, rax", - "xor r10, 91", - "sub r10, 1", - "sbb r10, r10", - "and r10, 48", - "or rcx, r10", - "mov r10, rax", - "xor r10, 92", - "sub r10, 1", - "sbb r10, r10", - "and r10, 163", - "or rcx, r10", - "mov r10, rax", - "xor r10, 93", - "sub r10, 1", - "sbb r10, r10", - "and r10, 60", - "or rcx, r10", - "mov r10, rax", - "xor r10, 94", - "sub r10, 1", - "sbb r10, r10", - "and r10, 182", - "or rcx, r10", - "mov r10, rax", - "xor r10, 95", - "sub r10, 1", - "sbb r10, r10", - "and r10, 38", - "or rcx, r10", - "mov r10, rax", - "xor r10, 96", - "sub r10, 1", - "sbb r10, r10", - "and r10, 111", - "or rcx, r10", - "mov r10, rax", - "xor r10, 97", - "sub r10, 1", - "sbb r10, r10", - "and r10, 191", - "or rcx, r10", - "mov r10, rax", - "xor r10, 98", - "sub r10, 1", - "sbb r10, r10", - "and r10, 14", - "or rcx, r10", - "mov r10, rax", - "xor r10, 99", - "sub r10, 1", - "sbb r10, r10", - "and r10, 218", - "or rcx, r10", - "mov r10, rax", - "xor r10, 100", - "sub r10, 1", - "sbb r10, r10", - "and r10, 70", - "or rcx, r10", - "mov r10, rax", - "xor r10, 101", - "sub r10, 1", - "sbb r10, r10", - "and r10, 105", - "or rcx, r10", - "mov r10, rax", - "xor r10, 102", - "sub r10, 1", - "sbb r10, r10", - "and r10, 7", - "or rcx, r10", - "mov r10, rax", - "xor r10, 103", - "sub r10, 1", - "sbb r10, r10", - "and r10, 87", - "or rcx, r10", - "mov r10, rax", - "xor r10, 104", - "sub r10, 1", - "sbb r10, r10", - "and r10, 39", - "or rcx, r10", - "mov r10, rax", - "xor r10, 105", - "sub r10, 1", - "sbb r10, r10", - "and r10, 242", - "or rcx, r10", - "mov r10, rax", - "xor r10, 106", - "sub r10, 1", - "sbb r10, r10", - "and r10, 29", - "or rcx, r10", - "mov r10, rax", - "xor r10, 107", - "sub r10, 1", - "sbb r10, r10", - "and r10, 155", - "or rcx, r10", - "mov r10, rax", - "xor r10, 108", - "sub r10, 1", - "sbb r10, r10", - "and r10, 188", - "or rcx, r10", - "mov r10, rax", - "xor r10, 109", - "sub r10, 1", - "sbb r10, r10", - "and r10, 148", - "or rcx, r10", - "mov r10, rax", - "xor r10, 110", - "sub r10, 1", - "sbb r10, r10", - "and r10, 67", - "or rcx, r10", - "mov r10, rax", - "xor r10, 111", - "sub r10, 1", - "sbb r10, r10", - "and r10, 3", - "or rcx, r10", - "mov r10, rax", - "xor r10, 112", - "sub r10, 1", - "sbb r10, r10", - "and r10, 248", - "or rcx, r10", - "mov r10, rax", - "xor r10, 113", - "sub r10, 1", - "sbb r10, r10", - "and r10, 17", - "or rcx, r10", - "mov r10, rax", - "xor r10, 114", - "sub r10, 1", - "sbb r10, r10", - "and r10, 199", - "or rcx, r10", - "mov r10, rax", - "xor r10, 115", - "sub r10, 1", - "sbb r10, r10", - "and r10, 246", - "or rcx, r10", - "mov r10, rax", - "xor r10, 116", - "sub r10, 1", - "sbb r10, r10", - "and r10, 144", - "or rcx, r10", - "mov r10, rax", - "xor r10, 117", - "sub r10, 1", - "sbb r10, r10", - "and r10, 239", - "or rcx, r10", - "mov r10, rax", - "xor r10, 118", - "sub r10, 1", - "sbb r10, r10", - "and r10, 62", - "or rcx, r10", - "mov r10, rax", - "xor r10, 119", - "sub r10, 1", - "sbb r10, r10", - "and r10, 231", - "or rcx, r10", - "mov r10, rax", - "xor r10, 120", - "sub r10, 1", - "sbb r10, r10", - "and r10, 6", - "or rcx, r10", - "mov r10, rax", - "xor r10, 121", - "sub r10, 1", - "sbb r10, r10", - "and r10, 195", - "or rcx, r10", - "mov r10, rax", - "xor r10, 122", - "sub r10, 1", - "sbb r10, r10", - "and r10, 213", - "or rcx, r10", - "mov r10, rax", - "xor r10, 123", - "sub r10, 1", - "sbb r10, r10", - "and r10, 47", - "or rcx, r10", - "mov r10, rax", - "xor r10, 124", - "sub r10, 1", - "sbb r10, r10", - "and r10, 200", - "or rcx, r10", - "mov r10, rax", - "xor r10, 125", - "sub r10, 1", - "sbb r10, r10", - "and r10, 102", - "or rcx, r10", - "mov r10, rax", - "xor r10, 126", - "sub r10, 1", - "sbb r10, r10", - "and r10, 30", - "or rcx, r10", - "mov r10, rax", - "xor r10, 127", - "sub r10, 1", - "sbb r10, r10", - "and r10, 215", - "or rcx, r10", - "mov r10, rax", - "xor r10, 128", - "sub r10, 1", - "sbb r10, r10", - "and r10, 8", - "or rcx, r10", - "mov r10, rax", - "xor r10, 129", - "sub r10, 1", - "sbb r10, r10", - "and r10, 232", - "or rcx, r10", - "mov r10, rax", - "xor r10, 130", - "sub r10, 1", - "sbb r10, r10", - "and r10, 234", - "or rcx, r10", - "mov r10, rax", - "xor r10, 131", - "sub r10, 1", - "sbb r10, r10", - "and r10, 222", - "or rcx, r10", - "mov r10, rax", - "xor r10, 132", - "sub r10, 1", - "sbb r10, r10", - "and r10, 128", - "or rcx, r10", - "mov r10, rax", - "xor r10, 133", - "sub r10, 1", - "sbb r10, r10", - "and r10, 82", - "or rcx, r10", - "mov r10, rax", - "xor r10, 134", - "sub r10, 1", - "sbb r10, r10", - "and r10, 238", - "or rcx, r10", - "mov r10, rax", - "xor r10, 135", - "sub r10, 1", - "sbb r10, r10", - "and r10, 247", - "or rcx, r10", - "mov r10, rax", - "xor r10, 136", - "sub r10, 1", - "sbb r10, r10", - "and r10, 132", - "or rcx, r10", - "mov r10, rax", - "xor r10, 137", - "sub r10, 1", - "sbb r10, r10", - "and r10, 170", - "or rcx, r10", - "mov r10, rax", - "xor r10, 138", - "sub r10, 1", - "sbb r10, r10", - "and r10, 114", - "or rcx, r10", - "mov r10, rax", - "xor r10, 139", - "sub r10, 1", - "sbb r10, r10", - "and r10, 172", - "or rcx, r10", - "mov r10, rax", - "xor r10, 140", - "sub r10, 1", - "sbb r10, r10", - "and r10, 53", - "or rcx, r10", - "mov r10, rax", - "xor r10, 141", - "sub r10, 1", - "sbb r10, r10", - "and r10, 77", - "or rcx, r10", - "mov r10, rax", - "xor r10, 142", - "sub r10, 1", - "sbb r10, r10", - "and r10, 106", - "or rcx, r10", - "mov r10, rax", - "xor r10, 143", - "sub r10, 1", - "sbb r10, r10", - "and r10, 42", - "or rcx, r10", - "mov r10, rax", - "xor r10, 144", - "sub r10, 1", - "sbb r10, r10", - "and r10, 150", - "or rcx, r10", - "mov r10, rax", - "xor r10, 145", - "sub r10, 1", - "sbb r10, r10", - "and r10, 26", - "or rcx, r10", - "mov r10, rax", - "xor r10, 146", - "sub r10, 1", - "sbb r10, r10", - "and r10, 210", - "or rcx, r10", - "mov r10, rax", - "xor r10, 147", - "sub r10, 1", - "sbb r10, r10", - "and r10, 113", - "or rcx, r10", - "mov r10, rax", - "xor r10, 148", - "sub r10, 1", - "sbb r10, r10", - "and r10, 90", - "or rcx, r10", - "mov r10, rax", - "xor r10, 149", - "sub r10, 1", - "sbb r10, r10", - "and r10, 21", - "or rcx, r10", - "mov r10, rax", - "xor r10, 150", - "sub r10, 1", - "sbb r10, r10", - "and r10, 73", - "or rcx, r10", - "mov r10, rax", - "xor r10, 151", - "sub r10, 1", - "sbb r10, r10", - "and r10, 116", - "or rcx, r10", - "mov r10, rax", - "xor r10, 152", - "sub r10, 1", - "sbb r10, r10", - "and r10, 75", - "or rcx, r10", - "mov r10, rax", - "xor r10, 153", - "sub r10, 1", - "sbb r10, r10", - "and r10, 159", - "or rcx, r10", - "mov r10, rax", - "xor r10, 154", - "sub r10, 1", - "sbb r10, r10", - "and r10, 208", - "or rcx, r10", - "mov r10, rax", - "xor r10, 155", - "sub r10, 1", - "sbb r10, r10", - "and r10, 94", - "or rcx, r10", - "mov r10, rax", - "xor r10, 156", - "sub r10, 1", - "sbb r10, r10", - "and r10, 4", - "or rcx, r10", - "mov r10, rax", - "xor r10, 157", - "sub r10, 1", - "sbb r10, r10", - "and r10, 24", - "or rcx, r10", - "mov r10, rax", - "xor r10, 158", - "sub r10, 1", - "sbb r10, r10", - "and r10, 164", - "or rcx, r10", - "mov r10, rax", - "xor r10, 159", - "sub r10, 1", - "sbb r10, r10", - "and r10, 236", - "or rcx, r10", - "mov r10, rax", - "xor r10, 160", - "sub r10, 1", - "sbb r10, r10", - "and r10, 194", - "or rcx, r10", - "mov r10, rax", - "xor r10, 161", - "sub r10, 1", - "sbb r10, r10", - "and r10, 224", - "or rcx, r10", - "mov r10, rax", - "xor r10, 162", - "sub r10, 1", - "sbb r10, r10", - "and r10, 65", - "or rcx, r10", - "mov r10, rax", - "xor r10, 163", - "sub r10, 1", - "sbb r10, r10", - "and r10, 110", - "or rcx, r10", - "mov r10, rax", - "xor r10, 164", - "sub r10, 1", - "sbb r10, r10", - "and r10, 15", - "or rcx, r10", - "mov r10, rax", - "xor r10, 165", - "sub r10, 1", - "sbb r10, r10", - "and r10, 81", - "or rcx, r10", - "mov r10, rax", - "xor r10, 166", - "sub r10, 1", - "sbb r10, r10", - "and r10, 203", - "or rcx, r10", - "mov r10, rax", - "xor r10, 167", - "sub r10, 1", - "sbb r10, r10", - "and r10, 204", - "or rcx, r10", - "mov r10, rax", - "xor r10, 168", - "sub r10, 1", - "sbb r10, r10", - "and r10, 36", - "or rcx, r10", - "mov r10, rax", - "xor r10, 169", - "sub r10, 1", - "sbb r10, r10", - "and r10, 145", - "or rcx, r10", - "mov r10, rax", - "xor r10, 170", - "sub r10, 1", - "sbb r10, r10", - "and r10, 175", - "or rcx, r10", - "mov r10, rax", - "xor r10, 171", - "sub r10, 1", - "sbb r10, r10", - "and r10, 80", - "or rcx, r10", - "mov r10, rax", - "xor r10, 172", - "sub r10, 1", - "sbb r10, r10", - "and r10, 161", - "or rcx, r10", - "mov r10, rax", - "xor r10, 173", - "sub r10, 1", - "sbb r10, r10", - "and r10, 244", - "or rcx, r10", - "mov r10, rax", - "xor r10, 174", - "sub r10, 1", - "sbb r10, r10", - "and r10, 112", - "or rcx, r10", - "mov r10, rax", - "xor r10, 175", - "sub r10, 1", - "sbb r10, r10", - "and r10, 57", - "or rcx, r10", - "mov r10, rax", - "xor r10, 176", - "sub r10, 1", - "sbb r10, r10", - "and r10, 153", - "or rcx, r10", - "mov r10, rax", - "xor r10, 177", - "sub r10, 1", - "sbb r10, r10", - "and r10, 124", - "or rcx, r10", - "mov r10, rax", - "xor r10, 178", - "sub r10, 1", - "sbb r10, r10", - "and r10, 58", - "or rcx, r10", - "mov r10, rax", - "xor r10, 179", - "sub r10, 1", - "sbb r10, r10", - "and r10, 133", - "or rcx, r10", - "mov r10, rax", - "xor r10, 180", - "sub r10, 1", - "sbb r10, r10", - "and r10, 35", - "or rcx, r10", - "mov r10, rax", - "xor r10, 181", - "sub r10, 1", - "sbb r10, r10", - "and r10, 184", - "or rcx, r10", - "mov r10, rax", - "xor r10, 182", - "sub r10, 1", - "sbb r10, r10", - "and r10, 180", - "or rcx, r10", - "mov r10, rax", - "xor r10, 183", - "sub r10, 1", - "sbb r10, r10", - "and r10, 122", - "or rcx, r10", - "mov r10, rax", - "xor r10, 184", - "sub r10, 1", - "sbb r10, r10", - "and r10, 252", - "or rcx, r10", - "mov r10, rax", - "xor r10, 185", - "sub r10, 1", - "sbb r10, r10", - "and r10, 2", - "or rcx, r10", - "mov r10, rax", - "xor r10, 186", - "sub r10, 1", - "sbb r10, r10", - "and r10, 54", - "or rcx, r10", - "mov r10, rax", - "xor r10, 187", - "sub r10, 1", - "sbb r10, r10", - "and r10, 91", - "or rcx, r10", - "mov r10, rax", - "xor r10, 188", - "sub r10, 1", - "sbb r10, r10", - "and r10, 37", - "or rcx, r10", - "mov r10, rax", - "xor r10, 189", - "sub r10, 1", - "sbb r10, r10", - "and r10, 85", - "or rcx, r10", - "mov r10, rax", - "xor r10, 190", - "sub r10, 1", - "sbb r10, r10", - "and r10, 151", - "or rcx, r10", - "mov r10, rax", - "xor r10, 191", - "sub r10, 1", - "sbb r10, r10", - "and r10, 49", - "or rcx, r10", - "mov r10, rax", - "xor r10, 192", - "sub r10, 1", - "sbb r10, r10", - "and r10, 45", - "or rcx, r10", - "mov r10, rax", - "xor r10, 193", - "sub r10, 1", - "sbb r10, r10", - "and r10, 93", - "or rcx, r10", - "mov r10, rax", - "xor r10, 194", - "sub r10, 1", - "sbb r10, r10", - "and r10, 250", - "or rcx, r10", - "mov r10, rax", - "xor r10, 195", - "sub r10, 1", - "sbb r10, r10", - "and r10, 152", - "or rcx, r10", - "mov r10, rax", - "xor r10, 196", - "sub r10, 1", - "sbb r10, r10", - "and r10, 227", - "or rcx, r10", - "mov r10, rax", - "xor r10, 197", - "sub r10, 1", - "sbb r10, r10", - "and r10, 138", - "or rcx, r10", - "mov r10, rax", - "xor r10, 198", - "sub r10, 1", - "sbb r10, r10", - "and r10, 146", - "or rcx, r10", - "mov r10, rax", - "xor r10, 199", - "sub r10, 1", - "sbb r10, r10", - "and r10, 174", - "or rcx, r10", - "mov r10, rax", - "xor r10, 200", - "sub r10, 1", - "sbb r10, r10", - "and r10, 5", - "or rcx, r10", - "mov r10, rax", - "xor r10, 201", - "sub r10, 1", - "sbb r10, r10", - "and r10, 223", - "or rcx, r10", - "mov r10, rax", - "xor r10, 202", - "sub r10, 1", - "sbb r10, r10", - "and r10, 41", - "or rcx, r10", - "mov r10, rax", - "xor r10, 203", - "sub r10, 1", - "sbb r10, r10", - "and r10, 16", - "or rcx, r10", - "mov r10, rax", - "xor r10, 204", - "sub r10, 1", - "sbb r10, r10", - "and r10, 103", - "or rcx, r10", - "mov r10, rax", - "xor r10, 205", - "sub r10, 1", - "sbb r10, r10", - "and r10, 108", - "or rcx, r10", - "mov r10, rax", - "xor r10, 206", - "sub r10, 1", - "sbb r10, r10", - "and r10, 186", - "or rcx, r10", - "mov r10, rax", - "xor r10, 207", - "sub r10, 1", - "sbb r10, r10", - "and r10, 201", - "or rcx, r10", - "mov r10, rax", - "xor r10, 208", - "sub r10, 1", - "sbb r10, r10", - "and r10, 211", - "or rcx, r10", - "mov r10, rax", - "xor r10, 209", - "sub r10, 1", - "sbb r10, r10", - "and r10, 0", - "or rcx, r10", - "mov r10, rax", - "xor r10, 210", - "sub r10, 1", - "sbb r10, r10", - "and r10, 230", - "or rcx, r10", - "mov r10, rax", - "xor r10, 211", - "sub r10, 1", - "sbb r10, r10", - "and r10, 207", - "or rcx, r10", - "mov r10, rax", - "xor r10, 212", - "sub r10, 1", - "sbb r10, r10", - "and r10, 225", - "or rcx, r10", - "mov r10, rax", - "xor r10, 213", - "sub r10, 1", - "sbb r10, r10", - "and r10, 158", - "or rcx, r10", - "mov r10, rax", - "xor r10, 214", - "sub r10, 1", - "sbb r10, r10", - "and r10, 168", - "or rcx, r10", - "mov r10, rax", - "xor r10, 215", - "sub r10, 1", - "sbb r10, r10", - "and r10, 44", - "or rcx, r10", - "mov r10, rax", - "xor r10, 216", - "sub r10, 1", - "sbb r10, r10", - "and r10, 99", - "or rcx, r10", - "mov r10, rax", - "xor r10, 217", - "sub r10, 1", - "sbb r10, r10", - "and r10, 22", - "or rcx, r10", - "mov r10, rax", - "xor r10, 218", - "sub r10, 1", - "sbb r10, r10", - "and r10, 1", - "or rcx, r10", - "mov r10, rax", - "xor r10, 219", - "sub r10, 1", - "sbb r10, r10", - "and r10, 63", - "or rcx, r10", - "mov r10, rax", - "xor r10, 220", - "sub r10, 1", - "sbb r10, r10", - "and r10, 88", - "or rcx, r10", - "mov r10, rax", - "xor r10, 221", - "sub r10, 1", - "sbb r10, r10", - "and r10, 226", - "or rcx, r10", - "mov r10, rax", - "xor r10, 222", - "sub r10, 1", - "sbb r10, r10", - "and r10, 137", - "or rcx, r10", - "mov r10, rax", - "xor r10, 223", - "sub r10, 1", - "sbb r10, r10", - "and r10, 169", - "or rcx, r10", - "mov r10, rax", - "xor r10, 224", - "sub r10, 1", - "sbb r10, r10", - "and r10, 13", - "or rcx, r10", - "mov r10, rax", - "xor r10, 225", - "sub r10, 1", - "sbb r10, r10", - "and r10, 56", - "or rcx, r10", - "mov r10, rax", - "xor r10, 226", - "sub r10, 1", - "sbb r10, r10", - "and r10, 52", - "or rcx, r10", - "mov r10, rax", - "xor r10, 227", - "sub r10, 1", - "sbb r10, r10", - "and r10, 27", - "or rcx, r10", - "mov r10, rax", - "xor r10, 228", - "sub r10, 1", - "sbb r10, r10", - "and r10, 171", - "or rcx, r10", - "mov r10, rax", - "xor r10, 229", - "sub r10, 1", - "sbb r10, r10", - "and r10, 51", - "or rcx, r10", - "mov r10, rax", - "xor r10, 230", - "sub r10, 1", - "sbb r10, r10", - "and r10, 255", - "or rcx, r10", - "mov r10, rax", - "xor r10, 231", - "sub r10, 1", - "sbb r10, r10", - "and r10, 176", - "or rcx, r10", - "mov r10, rax", - "xor r10, 232", - "sub r10, 1", - "sbb r10, r10", - "and r10, 187", - "or rcx, r10", - "mov r10, rax", - "xor r10, 233", - "sub r10, 1", - "sbb r10, r10", - "and r10, 72", - "or rcx, r10", - "mov r10, rax", - "xor r10, 234", - "sub r10, 1", - "sbb r10, r10", - "and r10, 12", - "or rcx, r10", - "mov r10, rax", - "xor r10, 235", - "sub r10, 1", - "sbb r10, r10", - "and r10, 95", - "or rcx, r10", - "mov r10, rax", - "xor r10, 236", - "sub r10, 1", - "sbb r10, r10", - "and r10, 185", - "or rcx, r10", - "mov r10, rax", - "xor r10, 237", - "sub r10, 1", - "sbb r10, r10", - "and r10, 177", - "or rcx, r10", - "mov r10, rax", - "xor r10, 238", - "sub r10, 1", - "sbb r10, r10", - "and r10, 205", - "or rcx, r10", - "mov r10, rax", - "xor r10, 239", - "sub r10, 1", - "sbb r10, r10", - "and r10, 46", - "or rcx, r10", - "mov r10, rax", - "xor r10, 240", - "sub r10, 1", - "sbb r10, r10", - "and r10, 197", - "or rcx, r10", - "mov r10, rax", - "xor r10, 241", - "sub r10, 1", - "sbb r10, r10", - "and r10, 243", - "or rcx, r10", - "mov r10, rax", - "xor r10, 242", - "sub r10, 1", - "sbb r10, r10", - "and r10, 219", - "or rcx, r10", - "mov r10, rax", - "xor r10, 243", - "sub r10, 1", - "sbb r10, r10", - "and r10, 71", - "or rcx, r10", - "mov r10, rax", - "xor r10, 244", - "sub r10, 1", - "sbb r10, r10", - "and r10, 229", - "or rcx, r10", - "mov r10, rax", - "xor r10, 245", - "sub r10, 1", - "sbb r10, r10", - "and r10, 165", - "or rcx, r10", - "mov r10, rax", - "xor r10, 246", - "sub r10, 1", - "sbb r10, r10", - "and r10, 156", - "or rcx, r10", - "mov r10, rax", - "xor r10, 247", - "sub r10, 1", - "sbb r10, r10", - "and r10, 119", - "or rcx, r10", - "mov r10, rax", - "xor r10, 248", - "sub r10, 1", - "sbb r10, r10", - "and r10, 10", - "or rcx, r10", - "mov r10, rax", - "xor r10, 249", - "sub r10, 1", - "sbb r10, r10", - "and r10, 166", - "or rcx, r10", - "mov r10, rax", - "xor r10, 250", - "sub r10, 1", - "sbb r10, r10", - "and r10, 32", - "or rcx, r10", - "mov r10, rax", - "xor r10, 251", - "sub r10, 1", - "sbb r10, r10", - "and r10, 104", - "or rcx, r10", - "mov r10, rax", - "xor r10, 252", - "sub r10, 1", - "sbb r10, r10", - "and r10, 254", - "or rcx, r10", - "mov r10, rax", - "xor r10, 253", - "sub r10, 1", - "sbb r10, r10", - "and r10, 127", - "or rcx, r10", - "mov r10, rax", - "xor r10, 254", - "sub r10, 1", - "sbb r10, r10", - "and r10, 193", - "or rcx, r10", - "mov r10, rax", - "xor r10, 255", - "sub r10, 1", - "sbb r10, r10", - "and r10, 173", - "or rcx, r10", - "mov rax, rcx", - "mov BYTE PTR [r14+rbx*1], al", - "cmp rbx, 0", - "jne 218f", - "jmp 219f", - "218:", - "220:", - "sub rbx, 1", - "movzx eax, BYTE PTR [r14+rbx*1+1]", - "mov r9, rbx", - "add r9, rbp", - "movzx ecx, BYTE PTR [r14+r9*1]", - "xor rax, rcx", - "and rax, 255", - "mov rcx, 0", - "mov r10, rax", - "xor r10, 0", - "sub r10, 1", - "sbb r10, r10", - "and r10, 217", - "or rcx, r10", - "mov r10, rax", - "xor r10, 1", - "sub r10, 1", - "sbb r10, r10", - "and r10, 120", - "or rcx, r10", - "mov r10, rax", - "xor r10, 2", - "sub r10, 1", - "sbb r10, r10", - "and r10, 249", - "or rcx, r10", - "mov r10, rax", - "xor r10, 3", - "sub r10, 1", - "sbb r10, r10", - "and r10, 196", - "or rcx, r10", - "mov r10, rax", - "xor r10, 4", - "sub r10, 1", - "sbb r10, r10", - "and r10, 25", - "or rcx, r10", - "mov r10, rax", - "xor r10, 5", - "sub r10, 1", - "sbb r10, r10", - "and r10, 221", - "or rcx, r10", - "mov r10, rax", - "xor r10, 6", - "sub r10, 1", - "sbb r10, r10", - "and r10, 181", - "or rcx, r10", - "mov r10, rax", - "xor r10, 7", - "sub r10, 1", - "sbb r10, r10", - "and r10, 237", - "or rcx, r10", - "mov r10, rax", - "xor r10, 8", - "sub r10, 1", - "sbb r10, r10", - "and r10, 40", - "or rcx, r10", - "mov r10, rax", - "xor r10, 9", - "sub r10, 1", - "sbb r10, r10", - "and r10, 233", - "or rcx, r10", - "mov r10, rax", - "xor r10, 10", - "sub r10, 1", - "sbb r10, r10", - "and r10, 253", - "or rcx, r10", - "mov r10, rax", - "xor r10, 11", - "sub r10, 1", - "sbb r10, r10", - "and r10, 121", - "or rcx, r10", - "mov r10, rax", - "xor r10, 12", - "sub r10, 1", - "sbb r10, r10", - "and r10, 74", - "or rcx, r10", - "mov r10, rax", - "xor r10, 13", - "sub r10, 1", - "sbb r10, r10", - "and r10, 160", - "or rcx, r10", - "mov r10, rax", - "xor r10, 14", - "sub r10, 1", - "sbb r10, r10", - "and r10, 216", - "or rcx, r10", - "mov r10, rax", - "xor r10, 15", - "sub r10, 1", - "sbb r10, r10", - "and r10, 157", - "or rcx, r10", - "mov r10, rax", - "xor r10, 16", - "sub r10, 1", - "sbb r10, r10", - "and r10, 198", - "or rcx, r10", - "mov r10, rax", - "xor r10, 17", - "sub r10, 1", - "sbb r10, r10", - "and r10, 126", - "or rcx, r10", - "mov r10, rax", - "xor r10, 18", - "sub r10, 1", - "sbb r10, r10", - "and r10, 55", - "or rcx, r10", - "mov r10, rax", - "xor r10, 19", - "sub r10, 1", - "sbb r10, r10", - "and r10, 131", - "or rcx, r10", - "mov r10, rax", - "xor r10, 20", - "sub r10, 1", - "sbb r10, r10", - "and r10, 43", - "or rcx, r10", - "mov r10, rax", - "xor r10, 21", - "sub r10, 1", - "sbb r10, r10", - "and r10, 118", - "or rcx, r10", - "mov r10, rax", - "xor r10, 22", - "sub r10, 1", - "sbb r10, r10", - "and r10, 83", - "or rcx, r10", - "mov r10, rax", - "xor r10, 23", - "sub r10, 1", - "sbb r10, r10", - "and r10, 142", - "or rcx, r10", - "mov r10, rax", - "xor r10, 24", - "sub r10, 1", - "sbb r10, r10", - "and r10, 98", - "or rcx, r10", - "mov r10, rax", - "xor r10, 25", - "sub r10, 1", - "sbb r10, r10", - "and r10, 76", - "or rcx, r10", - "mov r10, rax", - "xor r10, 26", - "sub r10, 1", - "sbb r10, r10", - "and r10, 100", - "or rcx, r10", - "mov r10, rax", - "xor r10, 27", - "sub r10, 1", - "sbb r10, r10", - "and r10, 136", - "or rcx, r10", - "mov r10, rax", - "xor r10, 28", - "sub r10, 1", - "sbb r10, r10", - "and r10, 68", - "or rcx, r10", - "mov r10, rax", - "xor r10, 29", - "sub r10, 1", - "sbb r10, r10", - "and r10, 139", - "or rcx, r10", - "mov r10, rax", - "xor r10, 30", - "sub r10, 1", - "sbb r10, r10", - "and r10, 251", - "or rcx, r10", - "mov r10, rax", - "xor r10, 31", - "sub r10, 1", - "sbb r10, r10", - "and r10, 162", - "or rcx, r10", - "mov r10, rax", - "xor r10, 32", - "sub r10, 1", - "sbb r10, r10", - "and r10, 23", - "or rcx, r10", - "mov r10, rax", - "xor r10, 33", - "sub r10, 1", - "sbb r10, r10", - "and r10, 154", - "or rcx, r10", - "mov r10, rax", - "xor r10, 34", - "sub r10, 1", - "sbb r10, r10", - "and r10, 89", - "or rcx, r10", - "mov r10, rax", - "xor r10, 35", - "sub r10, 1", - "sbb r10, r10", - "and r10, 245", - "or rcx, r10", - "mov r10, rax", - "xor r10, 36", - "sub r10, 1", - "sbb r10, r10", - "and r10, 135", - "or rcx, r10", - "mov r10, rax", - "xor r10, 37", - "sub r10, 1", - "sbb r10, r10", - "and r10, 179", - "or rcx, r10", - "mov r10, rax", - "xor r10, 38", - "sub r10, 1", - "sbb r10, r10", - "and r10, 79", - "or rcx, r10", - "mov r10, rax", - "xor r10, 39", - "sub r10, 1", - "sbb r10, r10", - "and r10, 19", - "or rcx, r10", - "mov r10, rax", - "xor r10, 40", - "sub r10, 1", - "sbb r10, r10", - "and r10, 97", - "or rcx, r10", - "mov r10, rax", - "xor r10, 41", - "sub r10, 1", - "sbb r10, r10", - "and r10, 69", - "or rcx, r10", - "mov r10, rax", - "xor r10, 42", - "sub r10, 1", - "sbb r10, r10", - "and r10, 109", - "or rcx, r10", - "mov r10, rax", - "xor r10, 43", - "sub r10, 1", - "sbb r10, r10", - "and r10, 141", - "or rcx, r10", - "mov r10, rax", - "xor r10, 44", - "sub r10, 1", - "sbb r10, r10", - "and r10, 9", - "or rcx, r10", - "mov r10, rax", - "xor r10, 45", - "sub r10, 1", - "sbb r10, r10", - "and r10, 129", - "or rcx, r10", - "mov r10, rax", - "xor r10, 46", - "sub r10, 1", - "sbb r10, r10", - "and r10, 125", - "or rcx, r10", - "mov r10, rax", - "xor r10, 47", - "sub r10, 1", - "sbb r10, r10", - "and r10, 50", - "or rcx, r10", - "mov r10, rax", - "xor r10, 48", - "sub r10, 1", - "sbb r10, r10", - "and r10, 189", - "or rcx, r10", - "mov r10, rax", - "xor r10, 49", - "sub r10, 1", - "sbb r10, r10", - "and r10, 143", - "or rcx, r10", - "mov r10, rax", - "xor r10, 50", - "sub r10, 1", - "sbb r10, r10", - "and r10, 64", - "or rcx, r10", - "mov r10, rax", - "xor r10, 51", - "sub r10, 1", - "sbb r10, r10", - "and r10, 235", - "or rcx, r10", - "mov r10, rax", - "xor r10, 52", - "sub r10, 1", - "sbb r10, r10", - "and r10, 134", - "or rcx, r10", - "mov r10, rax", - "xor r10, 53", - "sub r10, 1", - "sbb r10, r10", - "and r10, 183", - "or rcx, r10", - "mov r10, rax", - "xor r10, 54", - "sub r10, 1", - "sbb r10, r10", - "and r10, 123", - "or rcx, r10", - "mov r10, rax", - "xor r10, 55", - "sub r10, 1", - "sbb r10, r10", - "and r10, 11", - "or rcx, r10", - "mov r10, rax", - "xor r10, 56", - "sub r10, 1", - "sbb r10, r10", - "and r10, 240", - "or rcx, r10", - "mov r10, rax", - "xor r10, 57", - "sub r10, 1", - "sbb r10, r10", - "and r10, 149", - "or rcx, r10", - "mov r10, rax", - "xor r10, 58", - "sub r10, 1", - "sbb r10, r10", - "and r10, 33", - "or rcx, r10", - "mov r10, rax", - "xor r10, 59", - "sub r10, 1", - "sbb r10, r10", - "and r10, 34", - "or rcx, r10", - "mov r10, rax", - "xor r10, 60", - "sub r10, 1", - "sbb r10, r10", - "and r10, 92", - "or rcx, r10", - "mov r10, rax", - "xor r10, 61", - "sub r10, 1", - "sbb r10, r10", - "and r10, 107", - "or rcx, r10", - "mov r10, rax", - "xor r10, 62", - "sub r10, 1", - "sbb r10, r10", - "and r10, 78", - "or rcx, r10", - "mov r10, rax", - "xor r10, 63", - "sub r10, 1", - "sbb r10, r10", - "and r10, 130", - "or rcx, r10", - "mov r10, rax", - "xor r10, 64", - "sub r10, 1", - "sbb r10, r10", - "and r10, 84", - "or rcx, r10", - "mov r10, rax", - "xor r10, 65", - "sub r10, 1", - "sbb r10, r10", - "and r10, 214", - "or rcx, r10", - "mov r10, rax", - "xor r10, 66", - "sub r10, 1", - "sbb r10, r10", - "and r10, 101", - "or rcx, r10", - "mov r10, rax", - "xor r10, 67", - "sub r10, 1", - "sbb r10, r10", - "and r10, 147", - "or rcx, r10", - "mov r10, rax", - "xor r10, 68", - "sub r10, 1", - "sbb r10, r10", - "and r10, 206", - "or rcx, r10", - "mov r10, rax", - "xor r10, 69", - "sub r10, 1", - "sbb r10, r10", - "and r10, 96", - "or rcx, r10", - "mov r10, rax", - "xor r10, 70", - "sub r10, 1", - "sbb r10, r10", - "and r10, 178", - "or rcx, r10", - "mov r10, rax", - "xor r10, 71", - "sub r10, 1", - "sbb r10, r10", - "and r10, 28", - "or rcx, r10", - "mov r10, rax", - "xor r10, 72", - "sub r10, 1", - "sbb r10, r10", - "and r10, 115", - "or rcx, r10", - "mov r10, rax", - "xor r10, 73", - "sub r10, 1", - "sbb r10, r10", - "and r10, 86", - "or rcx, r10", - "mov r10, rax", - "xor r10, 74", - "sub r10, 1", - "sbb r10, r10", - "and r10, 192", - "or rcx, r10", - "mov r10, rax", - "xor r10, 75", - "sub r10, 1", - "sbb r10, r10", - "and r10, 20", - "or rcx, r10", - "mov r10, rax", - "xor r10, 76", - "sub r10, 1", - "sbb r10, r10", - "and r10, 167", - "or rcx, r10", - "mov r10, rax", - "xor r10, 77", - "sub r10, 1", - "sbb r10, r10", - "and r10, 140", - "or rcx, r10", - "mov r10, rax", - "xor r10, 78", - "sub r10, 1", - "sbb r10, r10", - "and r10, 241", - "or rcx, r10", - "mov r10, rax", - "xor r10, 79", - "sub r10, 1", - "sbb r10, r10", - "and r10, 220", - "or rcx, r10", - "mov r10, rax", - "xor r10, 80", - "sub r10, 1", - "sbb r10, r10", - "and r10, 18", - "or rcx, r10", - "mov r10, rax", - "xor r10, 81", - "sub r10, 1", - "sbb r10, r10", - "and r10, 117", - "or rcx, r10", - "mov r10, rax", - "xor r10, 82", - "sub r10, 1", - "sbb r10, r10", - "and r10, 202", - "or rcx, r10", - "mov r10, rax", - "xor r10, 83", - "sub r10, 1", - "sbb r10, r10", - "and r10, 31", - "or rcx, r10", - "mov r10, rax", - "xor r10, 84", - "sub r10, 1", - "sbb r10, r10", - "and r10, 59", - "or rcx, r10", - "mov r10, rax", - "xor r10, 85", - "sub r10, 1", - "sbb r10, r10", - "and r10, 190", - "or rcx, r10", - "mov r10, rax", - "xor r10, 86", - "sub r10, 1", - "sbb r10, r10", - "and r10, 228", - "or rcx, r10", - "mov r10, rax", - "xor r10, 87", - "sub r10, 1", - "sbb r10, r10", - "and r10, 209", - "or rcx, r10", - "mov r10, rax", - "xor r10, 88", - "sub r10, 1", - "sbb r10, r10", - "and r10, 66", - "or rcx, r10", - "mov r10, rax", - "xor r10, 89", - "sub r10, 1", - "sbb r10, r10", - "and r10, 61", - "or rcx, r10", - "mov r10, rax", - "xor r10, 90", - "sub r10, 1", - "sbb r10, r10", - "and r10, 212", - "or rcx, r10", - "mov r10, rax", - "xor r10, 91", - "sub r10, 1", - "sbb r10, r10", - "and r10, 48", - "or rcx, r10", - "mov r10, rax", - "xor r10, 92", - "sub r10, 1", - "sbb r10, r10", - "and r10, 163", - "or rcx, r10", - "mov r10, rax", - "xor r10, 93", - "sub r10, 1", - "sbb r10, r10", - "and r10, 60", - "or rcx, r10", - "mov r10, rax", - "xor r10, 94", - "sub r10, 1", - "sbb r10, r10", - "and r10, 182", - "or rcx, r10", - "mov r10, rax", - "xor r10, 95", - "sub r10, 1", - "sbb r10, r10", - "and r10, 38", - "or rcx, r10", - "mov r10, rax", - "xor r10, 96", - "sub r10, 1", - "sbb r10, r10", - "and r10, 111", - "or rcx, r10", - "mov r10, rax", - "xor r10, 97", - "sub r10, 1", - "sbb r10, r10", - "and r10, 191", - "or rcx, r10", - "mov r10, rax", - "xor r10, 98", - "sub r10, 1", - "sbb r10, r10", - "and r10, 14", - "or rcx, r10", - "mov r10, rax", - "xor r10, 99", - "sub r10, 1", - "sbb r10, r10", - "and r10, 218", - "or rcx, r10", - "mov r10, rax", - "xor r10, 100", - "sub r10, 1", - "sbb r10, r10", - "and r10, 70", - "or rcx, r10", - "mov r10, rax", - "xor r10, 101", - "sub r10, 1", - "sbb r10, r10", - "and r10, 105", - "or rcx, r10", - "mov r10, rax", - "xor r10, 102", - "sub r10, 1", - "sbb r10, r10", - "and r10, 7", - "or rcx, r10", - "mov r10, rax", - "xor r10, 103", - "sub r10, 1", - "sbb r10, r10", - "and r10, 87", - "or rcx, r10", - "mov r10, rax", - "xor r10, 104", - "sub r10, 1", - "sbb r10, r10", - "and r10, 39", - "or rcx, r10", - "mov r10, rax", - "xor r10, 105", - "sub r10, 1", - "sbb r10, r10", - "and r10, 242", - "or rcx, r10", - "mov r10, rax", - "xor r10, 106", - "sub r10, 1", - "sbb r10, r10", - "and r10, 29", - "or rcx, r10", - "mov r10, rax", - "xor r10, 107", - "sub r10, 1", - "sbb r10, r10", - "and r10, 155", - "or rcx, r10", - "mov r10, rax", - "xor r10, 108", - "sub r10, 1", - "sbb r10, r10", - "and r10, 188", - "or rcx, r10", - "mov r10, rax", - "xor r10, 109", - "sub r10, 1", - "sbb r10, r10", - "and r10, 148", - "or rcx, r10", - "mov r10, rax", - "xor r10, 110", - "sub r10, 1", - "sbb r10, r10", - "and r10, 67", - "or rcx, r10", - "mov r10, rax", - "xor r10, 111", - "sub r10, 1", - "sbb r10, r10", - "and r10, 3", - "or rcx, r10", - "mov r10, rax", - "xor r10, 112", - "sub r10, 1", - "sbb r10, r10", - "and r10, 248", - "or rcx, r10", - "mov r10, rax", - "xor r10, 113", - "sub r10, 1", - "sbb r10, r10", - "and r10, 17", - "or rcx, r10", - "mov r10, rax", - "xor r10, 114", - "sub r10, 1", - "sbb r10, r10", - "and r10, 199", - "or rcx, r10", - "mov r10, rax", - "xor r10, 115", - "sub r10, 1", - "sbb r10, r10", - "and r10, 246", - "or rcx, r10", - "mov r10, rax", - "xor r10, 116", - "sub r10, 1", - "sbb r10, r10", - "and r10, 144", - "or rcx, r10", - "mov r10, rax", - "xor r10, 117", - "sub r10, 1", - "sbb r10, r10", - "and r10, 239", - "or rcx, r10", - "mov r10, rax", - "xor r10, 118", - "sub r10, 1", - "sbb r10, r10", - "and r10, 62", - "or rcx, r10", - "mov r10, rax", - "xor r10, 119", - "sub r10, 1", - "sbb r10, r10", - "and r10, 231", - "or rcx, r10", - "mov r10, rax", - "xor r10, 120", - "sub r10, 1", - "sbb r10, r10", - "and r10, 6", - "or rcx, r10", - "mov r10, rax", - "xor r10, 121", - "sub r10, 1", - "sbb r10, r10", - "and r10, 195", - "or rcx, r10", - "mov r10, rax", - "xor r10, 122", - "sub r10, 1", - "sbb r10, r10", - "and r10, 213", - "or rcx, r10", - "mov r10, rax", - "xor r10, 123", - "sub r10, 1", - "sbb r10, r10", - "and r10, 47", - "or rcx, r10", - "mov r10, rax", - "xor r10, 124", - "sub r10, 1", - "sbb r10, r10", - "and r10, 200", - "or rcx, r10", - "mov r10, rax", - "xor r10, 125", - "sub r10, 1", - "sbb r10, r10", - "and r10, 102", - "or rcx, r10", - "mov r10, rax", - "xor r10, 126", - "sub r10, 1", - "sbb r10, r10", - "and r10, 30", - "or rcx, r10", - "mov r10, rax", - "xor r10, 127", - "sub r10, 1", - "sbb r10, r10", - "and r10, 215", - "or rcx, r10", - "mov r10, rax", - "xor r10, 128", - "sub r10, 1", - "sbb r10, r10", - "and r10, 8", - "or rcx, r10", - "mov r10, rax", - "xor r10, 129", - "sub r10, 1", - "sbb r10, r10", - "and r10, 232", - "or rcx, r10", - "mov r10, rax", - "xor r10, 130", - "sub r10, 1", - "sbb r10, r10", - "and r10, 234", - "or rcx, r10", - "mov r10, rax", - "xor r10, 131", - "sub r10, 1", - "sbb r10, r10", - "and r10, 222", - "or rcx, r10", - "mov r10, rax", - "xor r10, 132", - "sub r10, 1", - "sbb r10, r10", - "and r10, 128", - "or rcx, r10", - "mov r10, rax", - "xor r10, 133", - "sub r10, 1", - "sbb r10, r10", - "and r10, 82", - "or rcx, r10", - "mov r10, rax", - "xor r10, 134", - "sub r10, 1", - "sbb r10, r10", - "and r10, 238", - "or rcx, r10", - "mov r10, rax", - "xor r10, 135", - "sub r10, 1", - "sbb r10, r10", - "and r10, 247", - "or rcx, r10", - "mov r10, rax", - "xor r10, 136", - "sub r10, 1", - "sbb r10, r10", - "and r10, 132", - "or rcx, r10", - "mov r10, rax", - "xor r10, 137", - "sub r10, 1", - "sbb r10, r10", - "and r10, 170", - "or rcx, r10", - "mov r10, rax", - "xor r10, 138", - "sub r10, 1", - "sbb r10, r10", - "and r10, 114", - "or rcx, r10", - "mov r10, rax", - "xor r10, 139", - "sub r10, 1", - "sbb r10, r10", - "and r10, 172", - "or rcx, r10", - "mov r10, rax", - "xor r10, 140", - "sub r10, 1", - "sbb r10, r10", - "and r10, 53", - "or rcx, r10", - "mov r10, rax", - "xor r10, 141", - "sub r10, 1", - "sbb r10, r10", - "and r10, 77", - "or rcx, r10", - "mov r10, rax", - "xor r10, 142", - "sub r10, 1", - "sbb r10, r10", - "and r10, 106", - "or rcx, r10", - "mov r10, rax", - "xor r10, 143", - "sub r10, 1", - "sbb r10, r10", - "and r10, 42", - "or rcx, r10", - "mov r10, rax", - "xor r10, 144", - "sub r10, 1", - "sbb r10, r10", - "and r10, 150", - "or rcx, r10", - "mov r10, rax", - "xor r10, 145", - "sub r10, 1", - "sbb r10, r10", - "and r10, 26", - "or rcx, r10", - "mov r10, rax", - "xor r10, 146", - "sub r10, 1", - "sbb r10, r10", - "and r10, 210", - "or rcx, r10", - "mov r10, rax", - "xor r10, 147", - "sub r10, 1", - "sbb r10, r10", - "and r10, 113", - "or rcx, r10", - "mov r10, rax", - "xor r10, 148", - "sub r10, 1", - "sbb r10, r10", - "and r10, 90", - "or rcx, r10", - "mov r10, rax", - "xor r10, 149", - "sub r10, 1", - "sbb r10, r10", - "and r10, 21", - "or rcx, r10", - "mov r10, rax", - "xor r10, 150", - "sub r10, 1", - "sbb r10, r10", - "and r10, 73", - "or rcx, r10", - "mov r10, rax", - "xor r10, 151", - "sub r10, 1", - "sbb r10, r10", - "and r10, 116", - "or rcx, r10", - "mov r10, rax", - "xor r10, 152", - "sub r10, 1", - "sbb r10, r10", - "and r10, 75", - "or rcx, r10", - "mov r10, rax", - "xor r10, 153", - "sub r10, 1", - "sbb r10, r10", - "and r10, 159", - "or rcx, r10", - "mov r10, rax", - "xor r10, 154", - "sub r10, 1", - "sbb r10, r10", - "and r10, 208", - "or rcx, r10", - "mov r10, rax", - "xor r10, 155", - "sub r10, 1", - "sbb r10, r10", - "and r10, 94", - "or rcx, r10", - "mov r10, rax", - "xor r10, 156", - "sub r10, 1", - "sbb r10, r10", - "and r10, 4", - "or rcx, r10", - "mov r10, rax", - "xor r10, 157", - "sub r10, 1", - "sbb r10, r10", - "and r10, 24", - "or rcx, r10", - "mov r10, rax", - "xor r10, 158", - "sub r10, 1", - "sbb r10, r10", - "and r10, 164", - "or rcx, r10", - "mov r10, rax", - "xor r10, 159", - "sub r10, 1", - "sbb r10, r10", - "and r10, 236", - "or rcx, r10", - "mov r10, rax", - "xor r10, 160", - "sub r10, 1", - "sbb r10, r10", - "and r10, 194", - "or rcx, r10", - "mov r10, rax", - "xor r10, 161", - "sub r10, 1", - "sbb r10, r10", - "and r10, 224", - "or rcx, r10", - "mov r10, rax", - "xor r10, 162", - "sub r10, 1", - "sbb r10, r10", - "and r10, 65", - "or rcx, r10", - "mov r10, rax", - "xor r10, 163", - "sub r10, 1", - "sbb r10, r10", - "and r10, 110", - "or rcx, r10", - "mov r10, rax", - "xor r10, 164", - "sub r10, 1", - "sbb r10, r10", - "and r10, 15", - "or rcx, r10", - "mov r10, rax", - "xor r10, 165", - "sub r10, 1", - "sbb r10, r10", - "and r10, 81", - "or rcx, r10", - "mov r10, rax", - "xor r10, 166", - "sub r10, 1", - "sbb r10, r10", - "and r10, 203", - "or rcx, r10", - "mov r10, rax", - "xor r10, 167", - "sub r10, 1", - "sbb r10, r10", - "and r10, 204", - "or rcx, r10", - "mov r10, rax", - "xor r10, 168", - "sub r10, 1", - "sbb r10, r10", - "and r10, 36", - "or rcx, r10", - "mov r10, rax", - "xor r10, 169", - "sub r10, 1", - "sbb r10, r10", - "and r10, 145", - "or rcx, r10", - "mov r10, rax", - "xor r10, 170", - "sub r10, 1", - "sbb r10, r10", - "and r10, 175", - "or rcx, r10", - "mov r10, rax", - "xor r10, 171", - "sub r10, 1", - "sbb r10, r10", - "and r10, 80", - "or rcx, r10", - "mov r10, rax", - "xor r10, 172", - "sub r10, 1", - "sbb r10, r10", - "and r10, 161", - "or rcx, r10", - "mov r10, rax", - "xor r10, 173", - "sub r10, 1", - "sbb r10, r10", - "and r10, 244", - "or rcx, r10", - "mov r10, rax", - "xor r10, 174", - "sub r10, 1", - "sbb r10, r10", - "and r10, 112", - "or rcx, r10", - "mov r10, rax", - "xor r10, 175", - "sub r10, 1", - "sbb r10, r10", - "and r10, 57", - "or rcx, r10", - "mov r10, rax", - "xor r10, 176", - "sub r10, 1", - "sbb r10, r10", - "and r10, 153", - "or rcx, r10", - "mov r10, rax", - "xor r10, 177", - "sub r10, 1", - "sbb r10, r10", - "and r10, 124", - "or rcx, r10", - "mov r10, rax", - "xor r10, 178", - "sub r10, 1", - "sbb r10, r10", - "and r10, 58", - "or rcx, r10", - "mov r10, rax", - "xor r10, 179", - "sub r10, 1", - "sbb r10, r10", - "and r10, 133", - "or rcx, r10", - "mov r10, rax", - "xor r10, 180", - "sub r10, 1", - "sbb r10, r10", - "and r10, 35", - "or rcx, r10", - "mov r10, rax", - "xor r10, 181", - "sub r10, 1", - "sbb r10, r10", - "and r10, 184", - "or rcx, r10", - "mov r10, rax", - "xor r10, 182", - "sub r10, 1", - "sbb r10, r10", - "and r10, 180", - "or rcx, r10", - "mov r10, rax", - "xor r10, 183", - "sub r10, 1", - "sbb r10, r10", - "and r10, 122", - "or rcx, r10", - "mov r10, rax", - "xor r10, 184", - "sub r10, 1", - "sbb r10, r10", - "and r10, 252", - "or rcx, r10", - "mov r10, rax", - "xor r10, 185", - "sub r10, 1", - "sbb r10, r10", - "and r10, 2", - "or rcx, r10", - "mov r10, rax", - "xor r10, 186", - "sub r10, 1", - "sbb r10, r10", - "and r10, 54", - "or rcx, r10", - "mov r10, rax", - "xor r10, 187", - "sub r10, 1", - "sbb r10, r10", - "and r10, 91", - "or rcx, r10", - "mov r10, rax", - "xor r10, 188", - "sub r10, 1", - "sbb r10, r10", - "and r10, 37", - "or rcx, r10", - "mov r10, rax", - "xor r10, 189", - "sub r10, 1", - "sbb r10, r10", - "and r10, 85", - "or rcx, r10", - "mov r10, rax", - "xor r10, 190", - "sub r10, 1", - "sbb r10, r10", - "and r10, 151", - "or rcx, r10", - "mov r10, rax", - "xor r10, 191", - "sub r10, 1", - "sbb r10, r10", - "and r10, 49", - "or rcx, r10", - "mov r10, rax", - "xor r10, 192", - "sub r10, 1", - "sbb r10, r10", - "and r10, 45", - "or rcx, r10", - "mov r10, rax", - "xor r10, 193", - "sub r10, 1", - "sbb r10, r10", - "and r10, 93", - "or rcx, r10", - "mov r10, rax", - "xor r10, 194", - "sub r10, 1", - "sbb r10, r10", - "and r10, 250", - "or rcx, r10", - "mov r10, rax", - "xor r10, 195", - "sub r10, 1", - "sbb r10, r10", - "and r10, 152", - "or rcx, r10", - "mov r10, rax", - "xor r10, 196", - "sub r10, 1", - "sbb r10, r10", - "and r10, 227", - "or rcx, r10", - "mov r10, rax", - "xor r10, 197", - "sub r10, 1", - "sbb r10, r10", - "and r10, 138", - "or rcx, r10", - "mov r10, rax", - "xor r10, 198", - "sub r10, 1", - "sbb r10, r10", - "and r10, 146", - "or rcx, r10", - "mov r10, rax", - "xor r10, 199", - "sub r10, 1", - "sbb r10, r10", - "and r10, 174", - "or rcx, r10", - "mov r10, rax", - "xor r10, 200", - "sub r10, 1", - "sbb r10, r10", - "and r10, 5", - "or rcx, r10", - "mov r10, rax", - "xor r10, 201", - "sub r10, 1", - "sbb r10, r10", - "and r10, 223", - "or rcx, r10", - "mov r10, rax", - "xor r10, 202", - "sub r10, 1", - "sbb r10, r10", - "and r10, 41", - "or rcx, r10", - "mov r10, rax", - "xor r10, 203", - "sub r10, 1", - "sbb r10, r10", - "and r10, 16", - "or rcx, r10", - "mov r10, rax", - "xor r10, 204", - "sub r10, 1", - "sbb r10, r10", - "and r10, 103", - "or rcx, r10", - "mov r10, rax", - "xor r10, 205", - "sub r10, 1", - "sbb r10, r10", - "and r10, 108", - "or rcx, r10", - "mov r10, rax", - "xor r10, 206", - "sub r10, 1", - "sbb r10, r10", - "and r10, 186", - "or rcx, r10", - "mov r10, rax", - "xor r10, 207", - "sub r10, 1", - "sbb r10, r10", - "and r10, 201", - "or rcx, r10", - "mov r10, rax", - "xor r10, 208", - "sub r10, 1", - "sbb r10, r10", - "and r10, 211", - "or rcx, r10", - "mov r10, rax", - "xor r10, 209", - "sub r10, 1", - "sbb r10, r10", - "and r10, 0", - "or rcx, r10", - "mov r10, rax", - "xor r10, 210", - "sub r10, 1", - "sbb r10, r10", - "and r10, 230", - "or rcx, r10", - "mov r10, rax", - "xor r10, 211", - "sub r10, 1", - "sbb r10, r10", - "and r10, 207", - "or rcx, r10", - "mov r10, rax", - "xor r10, 212", - "sub r10, 1", - "sbb r10, r10", - "and r10, 225", - "or rcx, r10", - "mov r10, rax", - "xor r10, 213", - "sub r10, 1", - "sbb r10, r10", - "and r10, 158", - "or rcx, r10", - "mov r10, rax", - "xor r10, 214", - "sub r10, 1", - "sbb r10, r10", - "and r10, 168", - "or rcx, r10", - "mov r10, rax", - "xor r10, 215", - "sub r10, 1", - "sbb r10, r10", - "and r10, 44", - "or rcx, r10", - "mov r10, rax", - "xor r10, 216", - "sub r10, 1", - "sbb r10, r10", - "and r10, 99", - "or rcx, r10", - "mov r10, rax", - "xor r10, 217", - "sub r10, 1", - "sbb r10, r10", - "and r10, 22", - "or rcx, r10", - "mov r10, rax", - "xor r10, 218", - "sub r10, 1", - "sbb r10, r10", - "and r10, 1", - "or rcx, r10", - "mov r10, rax", - "xor r10, 219", - "sub r10, 1", - "sbb r10, r10", - "and r10, 63", - "or rcx, r10", - "mov r10, rax", - "xor r10, 220", - "sub r10, 1", - "sbb r10, r10", - "and r10, 88", - "or rcx, r10", - "mov r10, rax", - "xor r10, 221", - "sub r10, 1", - "sbb r10, r10", - "and r10, 226", - "or rcx, r10", - "mov r10, rax", - "xor r10, 222", - "sub r10, 1", - "sbb r10, r10", - "and r10, 137", - "or rcx, r10", - "mov r10, rax", - "xor r10, 223", - "sub r10, 1", - "sbb r10, r10", - "and r10, 169", - "or rcx, r10", - "mov r10, rax", - "xor r10, 224", - "sub r10, 1", - "sbb r10, r10", - "and r10, 13", - "or rcx, r10", - "mov r10, rax", - "xor r10, 225", - "sub r10, 1", - "sbb r10, r10", - "and r10, 56", - "or rcx, r10", - "mov r10, rax", - "xor r10, 226", - "sub r10, 1", - "sbb r10, r10", - "and r10, 52", - "or rcx, r10", - "mov r10, rax", - "xor r10, 227", - "sub r10, 1", - "sbb r10, r10", - "and r10, 27", - "or rcx, r10", - "mov r10, rax", - "xor r10, 228", - "sub r10, 1", - "sbb r10, r10", - "and r10, 171", - "or rcx, r10", - "mov r10, rax", - "xor r10, 229", - "sub r10, 1", - "sbb r10, r10", - "and r10, 51", - "or rcx, r10", - "mov r10, rax", - "xor r10, 230", - "sub r10, 1", - "sbb r10, r10", - "and r10, 255", - "or rcx, r10", - "mov r10, rax", - "xor r10, 231", - "sub r10, 1", - "sbb r10, r10", - "and r10, 176", - "or rcx, r10", - "mov r10, rax", - "xor r10, 232", - "sub r10, 1", - "sbb r10, r10", - "and r10, 187", - "or rcx, r10", - "mov r10, rax", - "xor r10, 233", - "sub r10, 1", - "sbb r10, r10", - "and r10, 72", - "or rcx, r10", - "mov r10, rax", - "xor r10, 234", - "sub r10, 1", - "sbb r10, r10", - "and r10, 12", - "or rcx, r10", - "mov r10, rax", - "xor r10, 235", - "sub r10, 1", - "sbb r10, r10", - "and r10, 95", - "or rcx, r10", - "mov r10, rax", - "xor r10, 236", - "sub r10, 1", - "sbb r10, r10", - "and r10, 185", - "or rcx, r10", - "mov r10, rax", - "xor r10, 237", - "sub r10, 1", - "sbb r10, r10", - "and r10, 177", - "or rcx, r10", - "mov r10, rax", - "xor r10, 238", - "sub r10, 1", - "sbb r10, r10", - "and r10, 205", - "or rcx, r10", - "mov r10, rax", - "xor r10, 239", - "sub r10, 1", - "sbb r10, r10", - "and r10, 46", - "or rcx, r10", - "mov r10, rax", - "xor r10, 240", - "sub r10, 1", - "sbb r10, r10", - "and r10, 197", - "or rcx, r10", - "mov r10, rax", - "xor r10, 241", - "sub r10, 1", - "sbb r10, r10", - "and r10, 243", - "or rcx, r10", - "mov r10, rax", - "xor r10, 242", - "sub r10, 1", - "sbb r10, r10", - "and r10, 219", - "or rcx, r10", - "mov r10, rax", - "xor r10, 243", - "sub r10, 1", - "sbb r10, r10", - "and r10, 71", - "or rcx, r10", - "mov r10, rax", - "xor r10, 244", - "sub r10, 1", - "sbb r10, r10", - "and r10, 229", - "or rcx, r10", - "mov r10, rax", - "xor r10, 245", - "sub r10, 1", - "sbb r10, r10", - "and r10, 165", - "or rcx, r10", - "mov r10, rax", - "xor r10, 246", - "sub r10, 1", - "sbb r10, r10", - "and r10, 156", - "or rcx, r10", - "mov r10, rax", - "xor r10, 247", - "sub r10, 1", - "sbb r10, r10", - "and r10, 119", - "or rcx, r10", - "mov r10, rax", - "xor r10, 248", - "sub r10, 1", - "sbb r10, r10", - "and r10, 10", - "or rcx, r10", - "mov r10, rax", - "xor r10, 249", - "sub r10, 1", - "sbb r10, r10", - "and r10, 166", - "or rcx, r10", - "mov r10, rax", - "xor r10, 250", - "sub r10, 1", - "sbb r10, r10", - "and r10, 32", - "or rcx, r10", - "mov r10, rax", - "xor r10, 251", - "sub r10, 1", - "sbb r10, r10", - "and r10, 104", - "or rcx, r10", - "mov r10, rax", - "xor r10, 252", - "sub r10, 1", - "sbb r10, r10", - "and r10, 254", - "or rcx, r10", - "mov r10, rax", - "xor r10, 253", - "sub r10, 1", - "sbb r10, r10", - "and r10, 127", - "or rcx, r10", - "mov r10, rax", - "xor r10, 254", - "sub r10, 1", - "sbb r10, r10", - "and r10, 193", - "or rcx, r10", - "mov r10, rax", - "xor r10, 255", - "sub r10, 1", - "sbb r10, r10", - "and r10, 173", - "or rcx, r10", - "mov rax, rcx", + "movq xmm0, rax", + "punpcklwd xmm0, xmm0", + "pshufd xmm0, xmm0, 0", + "pxor xmm1, xmm1", + "movabs r10, 844433520132096", + "movq xmm2, r10", + "movabs r10, 1970350607106052", + "movq xmm5, r10", + "punpcklqdq xmm2, xmm5", + "movabs r10, 281479271743489", + "movq xmm6, r10", + "movabs r10, 281479271743489", + "movq xmm5, r10", + "punpcklqdq xmm6, xmm5", + "movabs r10, 2251834173947912", + "movq xmm7, r10", + "movabs r10, 2251834173947912", + "movq xmm5, r10", + "punpcklqdq xmm7, xmm5", + "movabs r10, 55170164890009817", + "movq xmm4, r10", + "movabs r10, 66710346883989529", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 34059558823985192", + "movq xmm4, r10", + "movabs r10, 44192499066994762", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 36873458180554950", + "movq xmm4, r10", + "movabs r10, 39969803182932011", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 38281026334359650", + "movq xmm4, r10", + "movabs r10, 45600024273027140", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 68961751556292631", + "movq xmm4, r10", + "movabs r10, 5348363871649927", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 39688439872159841", + "movq xmm4, r10", + "movabs r10, 14074285714898953", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 66146894414282941", + "movq xmm4, r10", + "movabs r10, 3096753036787846", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 9570290951848176", + "movq xmm4, r10", + "movabs r10, 36592081986846812", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 41377255382188116", + "movq xmm4, r10", + "movabs r10, 7882063858368718", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 5630324173570163", + "movq xmm4, r10", + "movabs r10, 61925529972637863", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 8726591869091858", + "movq xmm4, r10", + "movabs r10, 58829249397522491", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 13511709419176002", + "movq xmm4, r10", + "movabs r10, 10696830802985123", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 61361605064982639", + "movq xmm4, r10", + "movabs r10, 24488353045479494", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 43628745960063015", + "movq xmm4, r10", + "movabs r10, 844712702640316", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 69243698970427640", + "movq xmm4, r10", + "movabs r10, 65020985923797136", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 13230238746214406", + "movq xmm4, r10", + "movabs r10, 60517248848494792", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 62488449867317256", + "movq xmm4, r10", + "movabs r10, 69525341455122560", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 48414185631645828", + "movq xmm4, r10", + "movabs r10, 11822404293427253", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 31807574313140374", + "movq xmm4, r10", + "movabs r10, 32651410832425050", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 26459541174419531", + "movq xmm4, r10", + "movabs r10, 66428798879924228", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 30962526625726658", + "movq xmm4, r10", + "movabs r10, 57421767132643343", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 22518749765632036", + "movq xmm4, r10", + "movabs r10, 16044554724835489", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 37436421018747033", + "movq xmm4, r10", + "movabs r10, 34340720264871971", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 25614454809035004", + "movq xmm4, r10", + "movabs r10, 13792922404454437", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 42785270207938605", + "movq xmm4, r10", + "movabs r10, 48977273021923555", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 4503775735644165", + "movq xmm4, r10", + "movabs r10, 56577269189836903", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 58266308021584083", + "movq xmm4, r10", + "movabs r10, 12385620540129505", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 17732927829180515", + "movq xmm4, r10", + "movabs r10, 47569859489431640", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 7600047713157133", + "movq xmm4, r10", + "movabs r10, 49540691121078443", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 26740174331838651", + "movq xmm4, r10", + "movabs r10, 12948729408585913", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 19985663960219845", + "movq xmm4, r10", + "movabs r10, 33496192254279909", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 29273535027740682", + "movq xmm4, r10", + "movabs r10, 48695999907954942", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqa xmm3, xmm1", + "psrldq xmm3, 8", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 4", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 2", + "por xmm1, xmm3", + "movdqu XMMWORD PTR [r8+64], xmm1", + "mov rax, QWORD PTR [r8+64]", + "and rax, 65535", + "movdqu XMMWORD PTR [r8+64], xmm8", + "mov BYTE PTR [r14+rbx*1], al", + "add rbx, 1", + "cmp rbx, 128", + "jne 23b", + "22:", + "mov rbp, r15", + "add rbp, 7", + "shr rbp, 3", + "mov rbx, 128", + "sub rbx, rbp", + "mov r9, r15", + "and r9, 7", + "mov rdx, 255", + "cmp r9, 1", + "je 24f", + "jmp 25f", + "24:", + "mov rdx, 1", + "25:", + "cmp r9, 2", + "je 26f", + "jmp 27f", + "26:", + "mov rdx, 3", + "27:", + "cmp r9, 3", + "je 28f", + "jmp 29f", + "28:", + "mov rdx, 7", + "29:", + "cmp r9, 4", + "je 210f", + "jmp 211f", + "210:", + "mov rdx, 15", + "211:", + "cmp r9, 5", + "je 212f", + "jmp 213f", + "212:", + "mov rdx, 31", + "213:", + "cmp r9, 6", + "je 214f", + "jmp 215f", + "214:", + "mov rdx, 63", + "215:", + "cmp r9, 7", + "je 216f", + "jmp 217f", + "216:", + "mov rdx, 127", + "217:", + "movzx eax, BYTE PTR [r14+rbx*1]", + "and rax, rdx", + "movdqu xmm8, XMMWORD PTR [r8+64]", + "and rax, 255", + "movq xmm0, rax", + "punpcklwd xmm0, xmm0", + "pshufd xmm0, xmm0, 0", + "pxor xmm1, xmm1", + "movabs r10, 844433520132096", + "movq xmm2, r10", + "movabs r10, 1970350607106052", + "movq xmm5, r10", + "punpcklqdq xmm2, xmm5", + "movabs r10, 281479271743489", + "movq xmm6, r10", + "movabs r10, 281479271743489", + "movq xmm5, r10", + "punpcklqdq xmm6, xmm5", + "movabs r10, 2251834173947912", + "movq xmm7, r10", + "movabs r10, 2251834173947912", + "movq xmm5, r10", + "punpcklqdq xmm7, xmm5", + "movabs r10, 55170164890009817", + "movq xmm4, r10", + "movabs r10, 66710346883989529", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 34059558823985192", + "movq xmm4, r10", + "movabs r10, 44192499066994762", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 36873458180554950", + "movq xmm4, r10", + "movabs r10, 39969803182932011", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 38281026334359650", + "movq xmm4, r10", + "movabs r10, 45600024273027140", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 68961751556292631", + "movq xmm4, r10", + "movabs r10, 5348363871649927", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 39688439872159841", + "movq xmm4, r10", + "movabs r10, 14074285714898953", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 66146894414282941", + "movq xmm4, r10", + "movabs r10, 3096753036787846", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 9570290951848176", + "movq xmm4, r10", + "movabs r10, 36592081986846812", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 41377255382188116", + "movq xmm4, r10", + "movabs r10, 7882063858368718", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 5630324173570163", + "movq xmm4, r10", + "movabs r10, 61925529972637863", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 8726591869091858", + "movq xmm4, r10", + "movabs r10, 58829249397522491", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 13511709419176002", + "movq xmm4, r10", + "movabs r10, 10696830802985123", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 61361605064982639", + "movq xmm4, r10", + "movabs r10, 24488353045479494", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 43628745960063015", + "movq xmm4, r10", + "movabs r10, 844712702640316", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 69243698970427640", + "movq xmm4, r10", + "movabs r10, 65020985923797136", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 13230238746214406", + "movq xmm4, r10", + "movabs r10, 60517248848494792", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 62488449867317256", + "movq xmm4, r10", + "movabs r10, 69525341455122560", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 48414185631645828", + "movq xmm4, r10", + "movabs r10, 11822404293427253", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 31807574313140374", + "movq xmm4, r10", + "movabs r10, 32651410832425050", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 26459541174419531", + "movq xmm4, r10", + "movabs r10, 66428798879924228", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 30962526625726658", + "movq xmm4, r10", + "movabs r10, 57421767132643343", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 22518749765632036", + "movq xmm4, r10", + "movabs r10, 16044554724835489", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 37436421018747033", + "movq xmm4, r10", + "movabs r10, 34340720264871971", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 25614454809035004", + "movq xmm4, r10", + "movabs r10, 13792922404454437", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 42785270207938605", + "movq xmm4, r10", + "movabs r10, 48977273021923555", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 4503775735644165", + "movq xmm4, r10", + "movabs r10, 56577269189836903", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 58266308021584083", + "movq xmm4, r10", + "movabs r10, 12385620540129505", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 17732927829180515", + "movq xmm4, r10", + "movabs r10, 47569859489431640", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 7600047713157133", + "movq xmm4, r10", + "movabs r10, 49540691121078443", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 26740174331838651", + "movq xmm4, r10", + "movabs r10, 12948729408585913", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 19985663960219845", + "movq xmm4, r10", + "movabs r10, 33496192254279909", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 29273535027740682", + "movq xmm4, r10", + "movabs r10, 48695999907954942", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqa xmm3, xmm1", + "psrldq xmm3, 8", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 4", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 2", + "por xmm1, xmm3", + "movdqu XMMWORD PTR [r8+64], xmm1", + "mov rax, QWORD PTR [r8+64]", + "and rax, 65535", + "movdqu XMMWORD PTR [r8+64], xmm8", + "mov BYTE PTR [r14+rbx*1], al", + "cmp rbx, 0", + "jne 218f", + "jmp 219f", + "218:", + "220:", + "sub rbx, 1", + "movzx eax, BYTE PTR [r14+rbx*1+1]", + "mov r9, rbx", + "add r9, rbp", + "movzx ecx, BYTE PTR [r14+r9*1]", + "xor rax, rcx", + "movdqu xmm8, XMMWORD PTR [r8+64]", + "and rax, 255", + "movq xmm0, rax", + "punpcklwd xmm0, xmm0", + "pshufd xmm0, xmm0, 0", + "pxor xmm1, xmm1", + "movabs r10, 844433520132096", + "movq xmm2, r10", + "movabs r10, 1970350607106052", + "movq xmm5, r10", + "punpcklqdq xmm2, xmm5", + "movabs r10, 281479271743489", + "movq xmm6, r10", + "movabs r10, 281479271743489", + "movq xmm5, r10", + "punpcklqdq xmm6, xmm5", + "movabs r10, 2251834173947912", + "movq xmm7, r10", + "movabs r10, 2251834173947912", + "movq xmm5, r10", + "punpcklqdq xmm7, xmm5", + "movabs r10, 55170164890009817", + "movq xmm4, r10", + "movabs r10, 66710346883989529", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 34059558823985192", + "movq xmm4, r10", + "movabs r10, 44192499066994762", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 36873458180554950", + "movq xmm4, r10", + "movabs r10, 39969803182932011", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 38281026334359650", + "movq xmm4, r10", + "movabs r10, 45600024273027140", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 68961751556292631", + "movq xmm4, r10", + "movabs r10, 5348363871649927", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 39688439872159841", + "movq xmm4, r10", + "movabs r10, 14074285714898953", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 66146894414282941", + "movq xmm4, r10", + "movabs r10, 3096753036787846", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 9570290951848176", + "movq xmm4, r10", + "movabs r10, 36592081986846812", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 41377255382188116", + "movq xmm4, r10", + "movabs r10, 7882063858368718", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 5630324173570163", + "movq xmm4, r10", + "movabs r10, 61925529972637863", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 8726591869091858", + "movq xmm4, r10", + "movabs r10, 58829249397522491", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 13511709419176002", + "movq xmm4, r10", + "movabs r10, 10696830802985123", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 61361605064982639", + "movq xmm4, r10", + "movabs r10, 24488353045479494", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 43628745960063015", + "movq xmm4, r10", + "movabs r10, 844712702640316", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 69243698970427640", + "movq xmm4, r10", + "movabs r10, 65020985923797136", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 13230238746214406", + "movq xmm4, r10", + "movabs r10, 60517248848494792", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 62488449867317256", + "movq xmm4, r10", + "movabs r10, 69525341455122560", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 48414185631645828", + "movq xmm4, r10", + "movabs r10, 11822404293427253", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 31807574313140374", + "movq xmm4, r10", + "movabs r10, 32651410832425050", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 26459541174419531", + "movq xmm4, r10", + "movabs r10, 66428798879924228", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 30962526625726658", + "movq xmm4, r10", + "movabs r10, 57421767132643343", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 22518749765632036", + "movq xmm4, r10", + "movabs r10, 16044554724835489", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 37436421018747033", + "movq xmm4, r10", + "movabs r10, 34340720264871971", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 25614454809035004", + "movq xmm4, r10", + "movabs r10, 13792922404454437", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 42785270207938605", + "movq xmm4, r10", + "movabs r10, 48977273021923555", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 4503775735644165", + "movq xmm4, r10", + "movabs r10, 56577269189836903", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 58266308021584083", + "movq xmm4, r10", + "movabs r10, 12385620540129505", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 17732927829180515", + "movq xmm4, r10", + "movabs r10, 47569859489431640", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 7600047713157133", + "movq xmm4, r10", + "movabs r10, 49540691121078443", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 26740174331838651", + "movq xmm4, r10", + "movabs r10, 12948729408585913", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 19985663960219845", + "movq xmm4, r10", + "movabs r10, 33496192254279909", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movabs r10, 29273535027740682", + "movq xmm4, r10", + "movabs r10, 48695999907954942", + "movq xmm5, r10", + "punpcklqdq xmm4, xmm5", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqa xmm3, xmm1", + "psrldq xmm3, 8", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 4", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 2", + "por xmm1, xmm3", + "movdqu XMMWORD PTR [r8+64], xmm1", + "mov rax, QWORD PTR [r8+64]", + "and rax, 65535", + "movdqu XMMWORD PTR [r8+64], xmm8", "mov BYTE PTR [r14+rbx*1], al", "cmp rbx, 0", "jne 220b", From e19ac43b3bfc2072e4962eed770dbf7ac337fccd Mon Sep 17 00:00:00 2001 From: Paul Kehrer Date: Thu, 1 Oct 2026 21:56:22 +0800 Subject: [PATCH 2/2] Vectorize x86-64 RC2 mashing schedule scans with SSE2 (#465) * Vectorize x86-64 RC2 mashing schedule scans with SSE2 * Use a fresh rustup home for ARM benchmark containers --------- Co-authored-by: Paul Kehrer <161495+reaperhulk@users.noreply.github.com> --- bench/benches/primitives/rc2_cbc.rs | 2 +- ci/bench_arches.py | 2 +- .../VerifiedGarbage/Artifacts/Rc2/X86_64.lean | 4 +- .../Impl/Rc2/X86_64/Block.lean | 4 +- .../Impl/Rc2/X86_64/Sse2KeyLookup.lean | 15 + .../Proof/Rc2/X86_64/Block.lean | 9 +- .../Proof/Rc2/X86_64/Cipher.lean | 26 +- .../Proof/Rc2/X86_64/Rounds.lean | 11 +- .../Proof/Rc2/X86_64/ScanMemory.lean | 28 + .../Proof/Rc2/X86_64/Sse2KeyLookup.lean | 90 + .../Proof/Rc2/X86_64/Sse2KeyStart.lean | 49 + .../Proof/Rc2/X86_64/Sse2KeySteps.lean | 90 + src/asm/x86_64/rc2.rs | 14712 ++++------------ 13 files changed, 3298 insertions(+), 11744 deletions(-) create mode 100644 lean/VerifiedGarbage/Impl/Rc2/X86_64/Sse2KeyLookup.lean create mode 100644 lean/VerifiedGarbage/Proof/Rc2/X86_64/ScanMemory.lean create mode 100644 lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2KeyLookup.lean create mode 100644 lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2KeyStart.lean create mode 100644 lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2KeySteps.lean diff --git a/bench/benches/primitives/rc2_cbc.rs b/bench/benches/primitives/rc2_cbc.rs index 014ee0a15..00eff2d70 100644 --- a/bench/benches/primitives/rc2_cbc.rs +++ b/bench/benches/primitives/rc2_cbc.rs @@ -3,7 +3,7 @@ use criterion::Criterion; /// The library modules whose code these benchmarks run. -pub const USES: &[&str] = &["rc2_cbc"]; +pub const USES: &[&str] = &["rc2_cbc", "rc2"]; #[cfg(any( target_arch = "x86_64", diff --git a/ci/bench_arches.py b/ci/bench_arches.py index da0356174..2cd598bb4 100644 --- a/ci/bench_arches.py +++ b/ci/bench_arches.py @@ -47,7 +47,7 @@ "arm": { "os": "ubuntu-24.04-arm", "image": "ghcr.io/pyca/cryptography-runner-ubuntu-rolling:armv7l", - "options": "--env RUSTUP_HOME=/root/.rustup", + "options": "--env RUSTUP_HOME=/tmp/verified-garbage-rustup", }, } diff --git a/lean/VerifiedGarbage/Artifacts/Rc2/X86_64.lean b/lean/VerifiedGarbage/Artifacts/Rc2/X86_64.lean index 2abe94ffd..fd63d8743 100644 --- a/lean/VerifiedGarbage/Artifacts/Rc2/X86_64.lean +++ b/lean/VerifiedGarbage/Artifacts/Rc2/X86_64.lean @@ -39,7 +39,7 @@ def artifacts : List Artifact := [ { Spec.Rc2.encryptBlockApi with target := X86_64.target doc := Spec.Rc2.encryptBlockApi.doc - (notes := ["Baseline x86-64. Mashing scans all 64 schedule words in a fixed order."]) + (notes := ["Baseline x86-64 SSE2. Mashing scans all 64 schedule words in a fixed order, eight words per vector."]) code := Impl.Rc2.X86_64.encryptBlock contract := Spec.Rc2.encryptBlockContract X86_64.abi stack := 0 @@ -48,7 +48,7 @@ def artifacts : List Artifact := [ { Spec.Rc2.decryptBlockApi with target := X86_64.target doc := Spec.Rc2.decryptBlockApi.doc - (notes := ["Baseline x86-64. Reverse mashing scans all 64 schedule words in a fixed order."]) + (notes := ["Baseline x86-64 SSE2. Reverse mashing scans all 64 schedule words in a fixed order, eight words per vector."]) code := Impl.Rc2.X86_64.decryptBlock contract := Spec.Rc2.decryptBlockContract X86_64.abi stack := 0 diff --git a/lean/VerifiedGarbage/Impl/Rc2/X86_64/Block.lean b/lean/VerifiedGarbage/Impl/Rc2/X86_64/Block.lean index a1c09ad79..bfa4c6015 100644 --- a/lean/VerifiedGarbage/Impl/Rc2/X86_64/Block.lean +++ b/lean/VerifiedGarbage/Impl/Rc2/X86_64/Block.lean @@ -1,4 +1,4 @@ -import VerifiedGarbage.Impl.Rc2.X86_64.Lookup +import VerifiedGarbage.Impl.Rc2.X86_64.Sse2KeyLookup /-! # RC2 block encryption and decryption on baseline x86-64 -/ @@ -48,7 +48,7 @@ def reverseMix (j i : Nat) : List Instr := .alu .and (wordReg i) (.imm 65535)] def mash (direction : Spec.Rc2.Direction) (i : Nat) : List Instr := - [rr .rax (wordReg (i + 3))] ++ keyLookup ++ + [rr .rax (wordReg (i + 3))] ++ Sse2.keyLookup ++ [.alu (if direction = .encrypt then .add else .sub) (wordReg i) (.reg .rax), .alu .and (wordReg i) (.imm 65535)] diff --git a/lean/VerifiedGarbage/Impl/Rc2/X86_64/Sse2KeyLookup.lean b/lean/VerifiedGarbage/Impl/Rc2/X86_64/Sse2KeyLookup.lean new file mode 100644 index 000000000..07221ba04 --- /dev/null +++ b/lean/VerifiedGarbage/Impl/Rc2/X86_64/Sse2KeyLookup.lean @@ -0,0 +1,15 @@ +import VerifiedGarbage.Impl.Rc2.X86_64.Sse2Lookup + +/-! # Eight-way constant-time RC2 schedule scans on baseline x86-64 -/ + +namespace VG.Impl.Rc2.X86_64.Sse2 + +open VG.X86_64 VG.Impl.Rc2.X86_64 + +def keyStep (n : Nat) : List Instr := + [.movdquLoad .xmm4 (memOp .rdi (16 * n))] ++ select + +def keyLookup : List Instr := + start .rdx 63 ++ (List.range 8).flatMap keyStep ++ finish .rdx + +end VG.Impl.Rc2.X86_64.Sse2 diff --git a/lean/VerifiedGarbage/Proof/Rc2/X86_64/Block.lean b/lean/VerifiedGarbage/Proof/Rc2/X86_64/Block.lean index d05d9967d..f9746202f 100644 --- a/lean/VerifiedGarbage/Proof/Rc2/X86_64/Block.lean +++ b/lean/VerifiedGarbage/Proof/Rc2/X86_64/Block.lean @@ -63,8 +63,15 @@ theorem block_correct (d : Spec.Rc2.Direction) (s : State) (hs : (blockContract intro i hi rw [h₂.2.rd, h₂.2.wr, h₂.2.reg .rdi (by decide), h₁.1, h₁.2.1, h₁.2.2.1, hrd, hwr] exact ⟨⟨s.gpr .rdi, 128⟩, by simp, Offset.contains_base _ (by omega) (by omega)⟩ + have scans₂ : ScanMemory s₂ := by + refine ⟨read₂, ?_, ?_⟩ + · intro i hi + rw [h₂.2.rd, h₂.2.wr, h₂.2.reg .rdi (by decide), h₁.1, h₁.2.1, h₁.2.2.1, hrd, hwr] + exact ⟨⟨s.gpr .rdi, 128⟩, by simp, Offset.contains_base _ (by omega) (by omega)⟩ + · rw [h₂.2.wr, h₂.2.reg .rdx (by decide), h₁.1, h₁.2.2.1, hwr] + exact ⟨⟨s.gpr .rdx, 256⟩, by simp, Offset.contains_base _ (by decide) (by decide)⟩ rw [WP.block_append_iff] - apply WP.mono (rounds_ok d s₂ _ h₂.1 read₂) + apply WP.mono (rounds_ok d s₂ _ h₂.1 scans₂) intro s₃ h₃ have keep₂₃ := h₂.2.trans h₃.2 have ptr₃ : s₃.gpr .rsi = s.gpr .rsi := (keep₂₃.reg .rsi (by decide)).trans (congrFun h₁.1 .rsi) diff --git a/lean/VerifiedGarbage/Proof/Rc2/X86_64/Cipher.lean b/lean/VerifiedGarbage/Proof/Rc2/X86_64/Cipher.lean index 6e02b333c..86f7f083c 100644 --- a/lean/VerifiedGarbage/Proof/Rc2/X86_64/Cipher.lean +++ b/lean/VerifiedGarbage/Proof/Rc2/X86_64/Cipher.lean @@ -9,11 +9,11 @@ open VG VG.X86_64 VG.Impl.Rc2.X86_64 theorem foldWords_ok (code : Nat → List Instr) (step : Spec.Rc2.Schedule → Nat → Spec.Rc2.State → Spec.Rc2.State) (is : List Nat) (correct : ∀ i ∈ is, ∀ (s : State) (v : Spec.Rc2.State), Words s v → - (∀ j < 128, InRegions (s.rd ++ s.wr) (s.gpr .rdi + BitVec.ofNat 64 j) 1) → + (ScanMemory s) → WP isa (.block (code i)) s (fun s' => Words s' (step (Spec.Rc2.scheduleAt s.mem (s.gpr .rdi)) i v) ∧ Keep roundWrites s s')) (s : State) (v : Spec.Rc2.State) (hv : Words s v) - (readable : ∀ j < 128, InRegions (s.rd ++ s.wr) (s.gpr .rdi + BitVec.ofNat 64 j) 1) : + (readable : ScanMemory s) : WP isa (.block (is.flatMap code)) s (fun s' => Words s' (is.foldl (fun v i => step (Spec.Rc2.scheduleAt s.mem (s.gpr .rdi)) i v) v) ∧ Keep roundWrites s s') := by @@ -26,9 +26,7 @@ theorem foldWords_ok (code : Nat → List Instr) apply WP.mono (correct i (by simp) s v hv readable) intro s₁ h₁ have ptr₁ := h₁.2.reg .rdi (by decide) - have read₁ : ∀ j < 128, - InRegions (s₁.rd ++ s₁.wr) (s₁.gpr .rdi + BitVec.ofNat 64 j) 1 := by - rw [h₁.2.rd, h₁.2.wr, ptr₁]; exact readable + have read₁ : ScanMemory s₁ := readable.keep h₁.2 (by decide) (by decide) apply WP.mono (ih (fun j hj => correct j (List.mem_cons_of_mem _ hj)) s₁ _ h₁.1 read₁) intro s₂ h₂ refine ⟨?_, h₁.2.trans h₂.2⟩ @@ -37,19 +35,19 @@ theorem foldWords_ok (code : Nat → List Instr) theorem mixRound_ok (s : State) (v : Spec.Rc2.State) (hv : Words s v) (j : Nat) (hj : j < 16) - (readable : ∀ k < 128, InRegions (s.rd ++ s.wr) (s.gpr .rdi + BitVec.ofNat 64 k) 1) : + (readable : ScanMemory s) : WP isa (.block ((List.range 4).flatMap (fun i => mix (4 * j + i) i))) s (fun s' => Words s' (Spec.Rc2.mixRound (Spec.Rc2.scheduleAt s.mem (s.gpr .rdi)) j v) ∧ Keep roundWrites s s') := by apply foldWords_ok (step := fun k i v => Spec.Rc2.mix k (4 * j + i) i v) _ _ _ s v hv readable intro i hi s v hv readable have bound := List.mem_range.mp hi - apply WP.mono (mix_ok s v hv i (4 * j + i) bound (by omega) readable) + apply WP.mono (mix_ok s v hv i (4 * j + i) bound (by omega) readable.bytes) exact fun _ h => ⟨h.1, h.2.round⟩ theorem reverseMixRound_ok (s : State) (v : Spec.Rc2.State) (hv : Words s v) (j : Nat) (hj : j < 16) - (readable : ∀ k < 128, InRegions (s.rd ++ s.wr) (s.gpr .rdi + BitVec.ofNat 64 k) 1) : + (readable : ScanMemory s) : WP isa (.block ([3, 2, 1, 0].flatMap (fun i => reverseMix (4 * j + i) i))) s (fun s' => Words s' (Spec.Rc2.reverseMixRound (Spec.Rc2.scheduleAt s.mem (s.gpr .rdi)) j v) ∧ Keep roundWrites s s') := by @@ -58,7 +56,7 @@ theorem reverseMixRound_ok (s : State) (v : Spec.Rc2.State) (hv : Words s v) have bound : i < 4 := by simp only [List.mem_cons, List.not_mem_nil, or_false] at hi omega - apply WP.mono (reverseMix_ok s v hv i (4 * j + i) bound (by omega) readable) + apply WP.mono (reverseMix_ok s v hv i (4 * j + i) bound (by omega) readable.bytes) exact fun _ h => ⟨h.1, h.2.round⟩ def mashRoundSpec (d : Spec.Rc2.Direction) (k : Spec.Rc2.Schedule) @@ -73,7 +71,7 @@ def order (d : Spec.Rc2.Direction) : List Nat := | .decrypt => [3, 2, 1, 0] theorem mashRound_ok (d : Spec.Rc2.Direction) (s : State) (v : Spec.Rc2.State) (hv : Words s v) - (readable : ∀ k < 128, InRegions (s.rd ++ s.wr) (s.gpr .rdi + BitVec.ofNat 64 k) 1) : + (readable : ScanMemory s) : WP isa (.block ((order d).flatMap (mash d))) s (fun s' => Words s' (mashRoundSpec d (Spec.Rc2.scheduleAt s.mem (s.gpr .rdi)) v) ∧ Keep roundWrites s s') := by @@ -100,7 +98,7 @@ def roundSpec (d : Spec.Rc2.Direction) (k : Spec.Rc2.Schedule) (j : Nat) theorem round_ok (d : Spec.Rc2.Direction) (s : State) (v : Spec.Rc2.State) (hv : Words s v) (j : Nat) (hj : j < 16) - (readable : ∀ k < 128, InRegions (s.rd ++ s.wr) (s.gpr .rdi + BitVec.ofNat 64 k) 1) : + (readable : ScanMemory s) : WP isa (.block (round d j)) s (fun s' => Words s' (roundSpec d (Spec.Rc2.scheduleAt s.mem (s.gpr .rdi)) j v) ∧ Keep roundWrites s s') := by @@ -111,9 +109,7 @@ theorem round_ok (d : Spec.Rc2.Direction) (s : State) (v : Spec.Rc2.State) (hv : by_cases h : j = 4 ∨ j = 10 · rw [ite_eq_left h] have ptr₁ := h₁.2.reg .rdi (by decide) - have read₁ : ∀ k < 128, - InRegions (s₁.rd ++ s₁.wr) (s₁.gpr .rdi + BitVec.ofNat 64 k) 1 := by - rw [h₁.2.rd, h₁.2.wr, ptr₁]; exact readable + have read₁ : ScanMemory s₁ := readable.keep h₁.2 (by decide) (by decide) apply WP.mono (mashRound_ok d s₁ v₁ h₁.1 read₁) intro s₂ h₂ rw [h₁.2.mem, ptr₁] at h₂ @@ -134,7 +130,7 @@ theorem round_ok (d : Spec.Rc2.Direction) (s : State) (v : Spec.Rc2.State) (hv : exact finish s₁ _ h₁ theorem rounds_ok (d : Spec.Rc2.Direction) (s : State) (v : Spec.Rc2.State) (hv : Words s v) - (readable : ∀ k < 128, InRegions (s.rd ++ s.wr) (s.gpr .rdi + BitVec.ofNat 64 k) 1) : + (readable : ScanMemory s) : WP isa (.block ((List.range 16).flatMap (round d))) s (fun s' => Words s' ((List.range 16).foldl (fun v j => roundSpec d (Spec.Rc2.scheduleAt s.mem (s.gpr .rdi)) j v) v) ∧ Keep roundWrites s s') := by diff --git a/lean/VerifiedGarbage/Proof/Rc2/X86_64/Rounds.lean b/lean/VerifiedGarbage/Proof/Rc2/X86_64/Rounds.lean index 55752db29..6044aa68a 100644 --- a/lean/VerifiedGarbage/Proof/Rc2/X86_64/Rounds.lean +++ b/lean/VerifiedGarbage/Proof/Rc2/X86_64/Rounds.lean @@ -1,3 +1,5 @@ +import VerifiedGarbage.Proof.Rc2.X86_64.Sse2KeyLookup +import VerifiedGarbage.Proof.Rc2.X86_64.ScanMemory import VerifiedGarbage.Impl.Rc2.X86_64.Block import VerifiedGarbage.Proof.Rc2.X86_64.Lookup import VerifiedGarbage.Proof.Rc2.Word @@ -340,8 +342,7 @@ def mashSpec (direction : Spec.Rc2.Direction) (k : Spec.Rc2.Schedule) theorem mash_ok (direction : Spec.Rc2.Direction) (s : State) (v : Spec.Rc2.State) (hv : Words s v) (i : Nat) (hi : i < 4) - (readable : ∀ k < 128, - InRegions (s.rd ++ s.wr) (s.gpr .rdi + BitVec.ofNat 64 k) 1) : + (readable : ScanMemory s) : WP isa (.block (mash direction i)) s (fun s' => Words s' (mashSpec direction (Spec.Rc2.scheduleAt s.mem (s.gpr .rdi)) i v) ∧ Keep (wordReg i :: temps) s s') := by @@ -359,10 +360,8 @@ theorem mash_ok (direction : Spec.Rc2.Direction) (s : State) · exact rd_setReg _ _ _ · exact wr_setReg _ _ _ have ptr₁ := keep₁.reg .rdi (by decide) - have read₁ : ∀ k < 128, - InRegions (s₁.rd ++ s₁.wr) (s₁.gpr .rdi + BitVec.ofNat 64 k) 1 := by - rw [keep₁.rd, keep₁.wr, ptr₁]; exact readable - apply WP.mono (keyLookup_ok s₁ read₁) + have read₁ : ScanMemory s₁ := readable.keep keep₁ (by decide) (by decide) + apply WP.mono (Sse2.keyLookup_ok s₁ read₁.vectors read₁.scratch) intro s₂ h₂ let k := Spec.Rc2.scheduleAt s.mem (s.gpr .rdi) let key := k.getD ((v.getD ((i + 3) % 4) 0 &&& 63).toNat) 0 diff --git a/lean/VerifiedGarbage/Proof/Rc2/X86_64/ScanMemory.lean b/lean/VerifiedGarbage/Proof/Rc2/X86_64/ScanMemory.lean new file mode 100644 index 000000000..9e0d9304f --- /dev/null +++ b/lean/VerifiedGarbage/Proof/Rc2/X86_64/ScanMemory.lean @@ -0,0 +1,28 @@ +import VerifiedGarbage.Proof.Rc2.X86_64.Lookup + +/-! # Existing contract permissions used by vector schedule scans -/ + +namespace VG.Proof.Rc2.X86_64 + +open VG VG.X86_64 + +structure ScanMemory (s : State) : Prop where + bytes : ∀ i < 128, InRegions (s.rd ++ s.wr) (s.gpr .rdi + BitVec.ofNat 64 i) 1 + vectors : ∀ i < 8, InRegions (s.rd ++ s.wr) (s.gpr .rdi + BitVec.ofNat 64 (16 * i)) 16 + scratch : InRegions s.wr (s.gpr .rdx + BitVec.ofNat 64 64) 16 + +instance (s : State) : CoeFun (ScanMemory s) + (fun _ => ∀ i, i < 128 → InRegions (s.rd ++ s.wr) (s.gpr .rdi + BitVec.ofNat 64 i) 1) where + coe := fun h => h.bytes + +theorem ScanMemory.keep {s s' : State} {rs : List Reg} (h : ScanMemory s) + (keep : Keep rs s s') (hk : .rdi ∉ rs) (hs : .rdx ∉ rs) : ScanMemory s' := by + constructor + · rw [keep.rd, keep.wr, keep.reg .rdi hk] + exact h.bytes + · rw [keep.rd, keep.wr, keep.reg .rdi hk] + exact h.vectors + · rw [keep.wr, keep.reg .rdx hs] + exact h.scratch + +end VG.Proof.Rc2.X86_64 diff --git a/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2KeyLookup.lean b/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2KeyLookup.lean new file mode 100644 index 000000000..b90d7814d --- /dev/null +++ b/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2KeyLookup.lean @@ -0,0 +1,90 @@ +import VerifiedGarbage.Proof.Rc2.X86_64.Sse2KeySteps +import VerifiedGarbage.Proof.Rc2.X86_64.Sse2Finish + +/-! # Verified constant-time SSE2 schedule lookup -/ + +namespace VG.Proof.Rc2.X86_64.Sse2 + +open VG VG.X86_64 VG.Impl.Rc2.X86_64 + +theorem schedule_readWord (m : Mem) (p : Addr) (i : Nat) (hi : i < 64) : + m.readW (p + BitVec.ofNat 64 (2 * i)) 16 = (Spec.Rc2.scheduleAt m p).getD i 0 := by + rw [scheduleAt_getD _ _ _ hi] + apply BitVec.eq_of_getLsbD_eq + intro j hj + simp only [Mem.readW, BitVec.getLsbD_setWidth, BitVec.getLsbD_or, + BitVec.getLsbD_shiftLeft, decide_eq_true hj, Bool.true_and] + rw [getLsbD_read _ _ (by omega)] + by_cases h : j < 8 + · simp only [h, decide_true, Bool.not_true, Bool.false_and, Bool.or_false, + Nat.div_eq_of_lt h, Nat.mod_eq_of_lt h, BitVec.add_zero] + · have hj' : j - 8 < 8 := by omega + simp only [h, decide_false, Bool.not_false] + have hdiv : j / 8 = 1 := by omega + have hmod : j % 8 = j - 8 := by omega + rw [hdiv, hmod] + have hp : p + BitVec.ofNat 64 (2 * i) + BitVec.ofNat 64 1 = + p + BitVec.ofNat 64 (2 * i + 1) := by rw [BitVec.add_assoc, ← BitVec.ofNat_add] + rw [hp] + simp (disch := omega) only [BitVec.getLsbD_of_ge, decide_eq_true, + Bool.true_and, Bool.false_or] + +theorem keyLookup_ok (s : State) + (hread : ∀ i < 8, InRegions (s.rd ++ s.wr) (s.gpr .rdi + BitVec.ofNat 64 (16 * i)) 16) + (hwrite : InRegions s.wr (s.gpr .rdx + BitVec.ofNat 64 64) 16) : + WP isa (.block Impl.Rc2.X86_64.Sse2.keyLookup) s (fun s' => + s'.gpr .rax = ((Spec.Rc2.scheduleAt s.mem (s.gpr .rdi)).getD + ((s.gpr .rax).setWidth 6).toNat 0).setWidth 64 ∧ + Keep [.rax, .rcx, .r8, .r9, .r10, .r11] s s') := by + have hsread : InRegions (s.rd ++ s.wr) (s.gpr .rdx + BitVec.ofNat 64 64) 16 := by + obtain ⟨r, hr, hc⟩ := hwrite + exact ⟨r, List.mem_append_right _ hr, hc⟩ + rw [Impl.Rc2.X86_64.Sse2.keyLookup, List.append_assoc, WP.block_append_iff] + obtain ⟨s₁, run₁, input₁, zero₁, idx₁, ones₁, eights₁, saved₁, keep₁⟩ := keyStart_ok s .rdx hsread + refine WP.of_runBlock ⟨s₁, run₁, ?_⟩ + rw [WP.block_append_iff, List.range_eq_range'] + let x : Byte := ((s.gpr .rax).setWidth 6).setWidth 8 + let f (i : Nat) := s.mem.readW (s.gpr .rdi + BitVec.ofNat 64 (2 * i)) 16 + have inv₁ : KeyScanInv f x 0 s₁ := + ⟨input₁, zero₁.trans (acc_zero _ _).symm, idx₁, ones₁, eights₁⟩ + have hf₁ : ∀ i < 64, f i = s₁.mem.readW (s₁.gpr .rdi + BitVec.ofNat 64 (2 * i)) 16 := by + rw [keep₁.mem, keep₁.reg .rdi (by decide)] + intro _ _; rfl + have hr₁ : ∀ i < 8, InRegions (s₁.rd ++ s₁.wr) (s₁.gpr .rdi + BitVec.ofNat 64 (16 * i)) 16 := by + rw [keep₁.rd, keep₁.wr, keep₁.reg .rdi (by decide)]; exact hread + apply WP.mono (keySteps_ok 8 0 (by decide) s₁ f x inv₁ hf₁ hr₁) + intro s₂ h₂ + rw [Impl.Rc2.X86_64.Sse2.finish, WP.block_append_iff] + obtain ⟨s₃, run₃, reduced₃, keep₃⟩ := reduceOr_ok s₂ + refine WP.of_runBlock ⟨s₃, run₃, ?_⟩ + have keep₂ : Keep [.rax, .r10] s₁ s₂ := h₂.2.1.weaken (by simp) + have keep₃' : Keep [.rax, .r10] s₂ s₃ := keep₃.keep.weaken (by simp) + have kept : Keep [.rax, .r10] s s₃ := (keep₁.trans keep₂).trans keep₃' + have ptr : s₃.gpr .rdx = s.gpr .rdx := kept.reg .rdx (by decide) + have wr₃ : InRegions s₃.wr (s₃.gpr .rdx + BitVec.ofNat 64 64) 16 := by + rw [kept.wr, ptr]; exact hwrite + have rd₃ : InRegions (s₃.rd ++ s₃.wr) (s₃.gpr .rdx + BitVec.ofNat 64 64) 8 := by + rw [kept.rd, kept.wr, ptr] + obtain ⟨r, hr, hc⟩ := hsread + exact ⟨r, hr, by unfold Region.Contains at hc ⊢; omega⟩ + have saved₃ : s₃.xmm .xmm8 = s₃.mem.readW (s₃.gpr .rdx + BitVec.ofNat 64 64) 128 := by + rw [keep₃.xmm .xmm8 (by decide), h₂.2.2, saved₁, kept.mem, ptr] + obtain ⟨s₄, run₄, out₄, keep₄⟩ := finishTail_ok s₃ .rdx (by decide) rd₃ wr₃ saved₃ + refine WP.of_runBlock ⟨s₄, run₄, ?_⟩ + constructor + · have xb : x.toNat < 64 := by + simp only [x, BitVec.toNat_setWidth] + have h := ((s.gpr .rax).setWidth 6).isLt + simp only [BitVec.toNat_setWidth] at h + omega + have xe : x.toNat = ((s.gpr .rax).setWidth 6).toNat := by + simp only [x, BitVec.toNat_setWidth] + have h := ((s.gpr .rax).setWidth 6).isLt + simp only [BitVec.toNat_setWidth] at h + omega + rw [out₄, reduced₃, h₂.1.acc, reduce_acc, ite_eq_left xb] + dsimp only [f] + rw [schedule_readWord _ _ _ xb, xe] + · exact (kept.trans (keep₄.weaken (by simp))).weaken (by simp) + +end VG.Proof.Rc2.X86_64.Sse2 diff --git a/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2KeyStart.lean b/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2KeyStart.lean new file mode 100644 index 000000000..068d9cdff --- /dev/null +++ b/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2KeyStart.lean @@ -0,0 +1,49 @@ +import VerifiedGarbage.Proof.Rc2.X86_64.Sse2Vector +import VerifiedGarbage.Impl.Rc2.X86_64.Sse2KeyLookup + +/-! # Initialization of SSE2 RC2 schedule lookup state -/ + +namespace VG.Proof.Rc2.X86_64.Sse2 + +open VG VG.X86_64 VG.X86_64.RegUpd VG.Impl.Rc2.X86_64 + +theorem keyStart_ok (s : State) (scratch : Reg) + (hread : InRegions (s.rd ++ s.wr) (s.gpr scratch + BitVec.ofNat 64 64) 16) : + ∃ s', runBlock isa (Sse2.start scratch 63) s = some s' ∧ + s'.xmm .xmm0 = broadcast (((s.gpr .rax).setWidth 6).setWidth 8) ∧ + s'.xmm .xmm1 = 0#128 ∧ s'.xmm .xmm2 = Sse2.indices 0 ∧ + s'.xmm .xmm6 = Sse2.ones ∧ s'.xmm .xmm7 = Sse2.eights ∧ + s'.xmm .xmm8 = s.mem.readW (s.gpr scratch + BitVec.ofNat 64 64) 128 ∧ + Keep [.rax, .r10] s s' := by + refine ⟨_, by + simp (config := {decide := true}) only [Sse2.start, Sse2.loadConst, + List.cons_append, List.nil_append, + runBlock_cons, runStep_some, runBlock_nil, exec, execAlu, readSrc, XOp.exec, + State.load128, State.ea, memOp, offset_nat, hread, ite_true, Option.bind_some, + Option.map_some, gpr_setReg, gpr_setXmm, gpr_arithFlags, + xmm_setReg, xmm_setXmm_self, xmm_setXmm_of_ne] + rfl, ?_⟩ + refine ⟨?_, ?_, ?_, ?_, ?_, ?_, ?_⟩ + · simp (config := {decide := true}) only [xmm_setXmm_self, xmm_setXmm_of_ne, xmm_setReg] + rw [show (63#32).signExtend 64 = (63 : BitVec 64) by decide, maskIndex] + apply ext_word + intro i hi + rw [broadcast, word_ofWords _ hi] + simpa using broadcast_word (((s.gpr .rax).setWidth 6).setWidth 8) i hi + · simp (config := {decide := true}) only [xmm_setXmm_self, xmm_setXmm_of_ne, xmm_setReg, + XBinOp.eval, BitVec.xor_self] + · simp (config := {decide := true}) only [xmm_setXmm_self, xmm_setXmm_of_ne, xmm_setReg] + · simp (config := {decide := true}) only [xmm_setXmm_self, xmm_setXmm_of_ne, xmm_setReg] + · simp only [xmm_setXmm_self] + exact movq_const _ + · simp (config := {decide := true}) only [xmm_setXmm_of_ne, xmm_setReg, + xmm_arithFlags, xmm_setXmm_self] + · constructor + · intro r hr + simp only [List.mem_cons, List.not_mem_nil, or_false, not_or] at hr + simp only [gpr_setXmm, gpr_setReg_of_ne _ _ hr.1, gpr_setReg_of_ne _ _ hr.2, gpr_arithFlags] + · simp only [mem_setXmm, mem_setReg, mem_arithFlags] + · simp only [rd_setXmm, rd_setReg, rd_arithFlags] + · simp only [wr_setXmm, wr_setReg, wr_arithFlags] + +end VG.Proof.Rc2.X86_64.Sse2 diff --git a/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2KeySteps.lean b/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2KeySteps.lean new file mode 100644 index 000000000..52f2b519e --- /dev/null +++ b/lean/VerifiedGarbage/Proof/Rc2/X86_64/Sse2KeySteps.lean @@ -0,0 +1,90 @@ +import VerifiedGarbage.Proof.Rc2.X86_64.Sse2KeyStart + +/-! # Composing eight-candidate schedule scans -/ + +namespace VG.Proof.Rc2.X86_64.Sse2 + +open VG VG.X86_64 VG.X86_64.RegUpd VG.Impl.Rc2.X86_64 + +structure KeyScanInv (f : Nat → BitVec 16) (x : Byte) (n : Nat) (s : State) : Prop where + input : s.xmm .xmm0 = broadcast x + acc : s.xmm .xmm1 = Sse2.acc f x.toNat n + indices : s.xmm .xmm2 = Impl.Rc2.X86_64.Sse2.indices n + ones : s.xmm .xmm6 = Impl.Rc2.X86_64.Sse2.ones + eights : s.xmm .xmm7 = Impl.Rc2.X86_64.Sse2.eights + +theorem keyLoad_ok (s : State) (n : Nat) + (hread : InRegions (s.rd ++ s.wr) (s.gpr .rdi + BitVec.ofNat 64 (16 * n)) 16) : + ∃ s', runBlock isa [.movdquLoad .xmm4 (memOp .rdi (16 * n))] s = some s' ∧ + s'.xmm .xmm4 = s.mem.readW (s.gpr .rdi + BitVec.ofNat 64 (16 * n)) 128 ∧ + KeepX [] [.xmm4] s s' := by + refine ⟨_, by + simp only [runBlock_cons, runStep_some, runBlock_nil, exec, State.load128, + State.ea, memOp, offset_nat, hread, ite_true, Option.map_some] + rfl, ?_⟩ + constructor + · exact xmm_setXmm_self _ _ _ + · constructor + · exact ⟨fun _ _ => rfl, rfl, rfl, rfl⟩ + · intro r hr + simp only [List.mem_cons, List.not_mem_nil, or_false] at hr + exact xmm_setXmm_of_ne _ _ hr + +theorem keyStep_ok (s : State) (f : Nat → BitVec 16) (x : Byte) (n : Nat) (hn : n < 8) + (hinv : KeyScanInv f x n s) + (hf : ∀ i < 64, f i = s.mem.readW (s.gpr .rdi + BitVec.ofNat 64 (2 * i)) 16) + (hread : InRegions (s.rd ++ s.wr) (s.gpr .rdi + BitVec.ofNat 64 (16 * n)) 16) : + WP isa (.block (Impl.Rc2.X86_64.Sse2.keyStep n)) s (fun s' => + KeyScanInv f x (n + 1) s' ∧ Keep [] s s' ∧ s'.xmm .xmm8 = s.xmm .xmm8) := by + rw [Impl.Rc2.X86_64.Sse2.keyStep, WP.block_append_iff] + obtain ⟨s₁, run₁, val₁, keep₁⟩ := keyLoad_ok s n hread + refine WP.of_runBlock ⟨s₁, run₁, ?_⟩ + obtain ⟨s₂, run₂, val₂, idx₂, keep₂⟩ := select_ok s₁ + refine WP.of_runBlock ⟨s₂, run₂, ?_⟩ + refine ⟨?_, keep₁.keep.trans keep₂.keep, ?_⟩ + · constructor + · rw [keep₂.xmm .xmm0 (by decide), keep₁.xmm .xmm0 (by decide)] + exact hinv.input + · rw [val₂, keep₁.xmm .xmm1 (by decide), keep₁.xmm .xmm0 (by decide), + keep₁.xmm .xmm2 (by decide), keep₁.xmm .xmm6 (by decide), val₁, + hinv.acc, hinv.input, hinv.indices, hinv.ones] + apply acc_step f x n (by omega) + intro j hj + rw [word_readW _ _ hj, hf (8 * n + j) (by omega)] + rw [BitVec.add_assoc, ← BitVec.ofNat_add] + exact congrArg (fun d => s.mem.readW (s.gpr .rdi + BitVec.ofNat 64 d) 16) (by omega) + · rw [idx₂, keep₁.xmm .xmm2 (by decide), keep₁.xmm .xmm7 (by decide), + hinv.indices, hinv.eights] + exact indices_next n + · rw [keep₂.xmm .xmm6 (by decide), keep₁.xmm .xmm6 (by decide)] + exact hinv.ones + · rw [keep₂.xmm .xmm7 (by decide), keep₁.xmm .xmm7 (by decide)] + exact hinv.eights + · rw [keep₂.xmm .xmm8 (by decide), keep₁.xmm .xmm8 (by decide)] + +theorem keySteps_ok (count n : Nat) (hbound : n + count ≤ 8) + (s : State) (f : Nat → BitVec 16) (x : Byte) (hinv : KeyScanInv f x n s) + (hf : ∀ i < 64, f i = s.mem.readW (s.gpr .rdi + BitVec.ofNat 64 (2 * i)) 16) + (hread : ∀ i < 8, InRegions (s.rd ++ s.wr) (s.gpr .rdi + BitVec.ofNat 64 (16 * i)) 16) : + WP isa (.block ((List.range' n count).flatMap Impl.Rc2.X86_64.Sse2.keyStep)) s + (fun s' => KeyScanInv f x (n + count) s' ∧ Keep [] s s' ∧ + s'.xmm .xmm8 = s.xmm .xmm8) := by + induction count generalizing n s with + | zero => + apply WP.block_nil + exact ⟨hinv, ⟨fun _ _ => rfl, rfl, rfl, rfl⟩, rfl⟩ + | succ count ih => + rw [List.range'_succ, List.flatMap_cons, WP.block_append_iff] + apply WP.mono (keyStep_ok s f x n (by omega) hinv hf (hread n (by omega))) + intro s₁ h₁ + have hf₁ : ∀ i < 64, f i = s₁.mem.readW (s₁.gpr .rdi + BitVec.ofNat 64 (2 * i)) 16 := by + rw [h₁.2.1.mem, h₁.2.1.reg .rdi (by simp)]; exact hf + have hr₁ : ∀ i < 8, InRegions (s₁.rd ++ s₁.wr) (s₁.gpr .rdi + BitVec.ofNat 64 (16 * i)) 16 := by + rw [h₁.2.1.rd, h₁.2.1.wr, h₁.2.1.reg .rdi (by simp)]; exact hread + apply WP.mono (ih (n + 1) (by omega) s₁ h₁.1 hf₁ hr₁) + intro s₂ h₂ + refine ⟨?_, h₁.2.1.trans h₂.2.1, h₂.2.2.trans h₁.2.2⟩ + have he : n + 1 + count = n + (count + 1) := by omega + exact he ▸ h₂.1 + +end VG.Proof.Rc2.X86_64.Sse2 diff --git a/src/asm/x86_64/rc2.rs b/src/asm/x86_64/rc2.rs index 33755a4e8..8ea1dfab0 100644 --- a/src/asm/x86_64/rc2.rs +++ b/src/asm/x86_64/rc2.rs @@ -1483,7 +1483,7 @@ pub(crate) unsafe extern "sysv64" fn vg_rc2_expand_key(key: *const u8, key_len: /// /// Contract: `VG.Spec.Rc2.encryptBlockContract`. Constant time: only pointers may affect timing, not the key schedule or data, including the mashing indices. /// -/// Baseline x86-64. Mashing scans all 64 schedule words in a fixed order. +/// Baseline x86-64 SSE2. Mashing scans all 64 schedule words in a fixed order, eight words per vector. /// /// # Safety /// @@ -1873,9344 +1873,445 @@ pub(crate) unsafe extern "sysv64" fn vg_rc2_encrypt_block(schedule: *const [u8; "or r15, rax", "and r15, 65535", "mov rax, r15", + "movdqu xmm8, XMMWORD PTR [rdx+64]", "and rax, 63", - "mov rcx, 0", - "mov r10, rax", - "xor r10, 0", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi]", - "movzx r9d, BYTE PTR [rdi+1]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 1", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+2]", - "movzx r9d, BYTE PTR [rdi+3]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 2", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+4]", - "movzx r9d, BYTE PTR [rdi+5]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 3", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+6]", - "movzx r9d, BYTE PTR [rdi+7]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 4", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+8]", - "movzx r9d, BYTE PTR [rdi+9]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 5", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+10]", - "movzx r9d, BYTE PTR [rdi+11]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 6", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+12]", - "movzx r9d, BYTE PTR [rdi+13]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 7", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+14]", - "movzx r9d, BYTE PTR [rdi+15]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 8", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+16]", - "movzx r9d, BYTE PTR [rdi+17]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 9", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+18]", - "movzx r9d, BYTE PTR [rdi+19]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 10", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+20]", - "movzx r9d, BYTE PTR [rdi+21]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 11", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+22]", - "movzx r9d, BYTE PTR [rdi+23]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 12", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+24]", - "movzx r9d, BYTE PTR [rdi+25]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 13", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+26]", - "movzx r9d, BYTE PTR [rdi+27]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 14", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+28]", - "movzx r9d, BYTE PTR [rdi+29]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 15", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+30]", - "movzx r9d, BYTE PTR [rdi+31]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 16", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+32]", - "movzx r9d, BYTE PTR [rdi+33]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 17", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+34]", - "movzx r9d, BYTE PTR [rdi+35]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 18", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+36]", - "movzx r9d, BYTE PTR [rdi+37]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 19", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+38]", - "movzx r9d, BYTE PTR [rdi+39]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 20", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+40]", - "movzx r9d, BYTE PTR [rdi+41]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 21", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+42]", - "movzx r9d, BYTE PTR [rdi+43]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 22", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+44]", - "movzx r9d, BYTE PTR [rdi+45]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 23", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+46]", - "movzx r9d, BYTE PTR [rdi+47]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 24", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+48]", - "movzx r9d, BYTE PTR [rdi+49]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 25", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+50]", - "movzx r9d, BYTE PTR [rdi+51]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 26", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+52]", - "movzx r9d, BYTE PTR [rdi+53]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 27", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+54]", - "movzx r9d, BYTE PTR [rdi+55]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 28", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+56]", - "movzx r9d, BYTE PTR [rdi+57]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 29", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+58]", - "movzx r9d, BYTE PTR [rdi+59]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 30", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+60]", - "movzx r9d, BYTE PTR [rdi+61]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 31", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+62]", - "movzx r9d, BYTE PTR [rdi+63]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 32", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+64]", - "movzx r9d, BYTE PTR [rdi+65]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 33", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+66]", - "movzx r9d, BYTE PTR [rdi+67]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 34", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+68]", - "movzx r9d, BYTE PTR [rdi+69]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 35", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+70]", - "movzx r9d, BYTE PTR [rdi+71]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 36", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+72]", - "movzx r9d, BYTE PTR [rdi+73]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 37", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+74]", - "movzx r9d, BYTE PTR [rdi+75]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 38", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+76]", - "movzx r9d, BYTE PTR [rdi+77]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 39", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+78]", - "movzx r9d, BYTE PTR [rdi+79]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 40", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+80]", - "movzx r9d, BYTE PTR [rdi+81]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 41", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+82]", - "movzx r9d, BYTE PTR [rdi+83]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 42", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+84]", - "movzx r9d, BYTE PTR [rdi+85]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 43", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+86]", - "movzx r9d, BYTE PTR [rdi+87]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 44", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+88]", - "movzx r9d, BYTE PTR [rdi+89]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 45", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+90]", - "movzx r9d, BYTE PTR [rdi+91]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 46", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+92]", - "movzx r9d, BYTE PTR [rdi+93]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 47", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+94]", - "movzx r9d, BYTE PTR [rdi+95]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 48", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+96]", - "movzx r9d, BYTE PTR [rdi+97]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 49", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+98]", - "movzx r9d, BYTE PTR [rdi+99]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 50", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+100]", - "movzx r9d, BYTE PTR [rdi+101]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 51", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+102]", - "movzx r9d, BYTE PTR [rdi+103]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 52", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+104]", - "movzx r9d, BYTE PTR [rdi+105]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 53", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+106]", - "movzx r9d, BYTE PTR [rdi+107]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 54", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+108]", - "movzx r9d, BYTE PTR [rdi+109]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 55", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+110]", - "movzx r9d, BYTE PTR [rdi+111]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 56", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+112]", - "movzx r9d, BYTE PTR [rdi+113]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 57", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+114]", - "movzx r9d, BYTE PTR [rdi+115]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 58", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+116]", - "movzx r9d, BYTE PTR [rdi+117]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 59", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+118]", - "movzx r9d, BYTE PTR [rdi+119]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 60", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+120]", - "movzx r9d, BYTE PTR [rdi+121]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 61", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+122]", - "movzx r9d, BYTE PTR [rdi+123]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 62", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+124]", - "movzx r9d, BYTE PTR [rdi+125]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 63", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+126]", - "movzx r9d, BYTE PTR [rdi+127]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov rax, rcx", - "add r12, rax", - "and r12, 65535", - "mov rax, r12", - "and rax, 63", - "mov rcx, 0", - "mov r10, rax", - "xor r10, 0", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi]", - "movzx r9d, BYTE PTR [rdi+1]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 1", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+2]", - "movzx r9d, BYTE PTR [rdi+3]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 2", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+4]", - "movzx r9d, BYTE PTR [rdi+5]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 3", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+6]", - "movzx r9d, BYTE PTR [rdi+7]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 4", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+8]", - "movzx r9d, BYTE PTR [rdi+9]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 5", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+10]", - "movzx r9d, BYTE PTR [rdi+11]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 6", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+12]", - "movzx r9d, BYTE PTR [rdi+13]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 7", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+14]", - "movzx r9d, BYTE PTR [rdi+15]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 8", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+16]", - "movzx r9d, BYTE PTR [rdi+17]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 9", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+18]", - "movzx r9d, BYTE PTR [rdi+19]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 10", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+20]", - "movzx r9d, BYTE PTR [rdi+21]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 11", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+22]", - "movzx r9d, BYTE PTR [rdi+23]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 12", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+24]", - "movzx r9d, BYTE PTR [rdi+25]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 13", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+26]", - "movzx r9d, BYTE PTR [rdi+27]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 14", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+28]", - "movzx r9d, BYTE PTR [rdi+29]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 15", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+30]", - "movzx r9d, BYTE PTR [rdi+31]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 16", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+32]", - "movzx r9d, BYTE PTR [rdi+33]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 17", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+34]", - "movzx r9d, BYTE PTR [rdi+35]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 18", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+36]", - "movzx r9d, BYTE PTR [rdi+37]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 19", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+38]", - "movzx r9d, BYTE PTR [rdi+39]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 20", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+40]", - "movzx r9d, BYTE PTR [rdi+41]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 21", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+42]", - "movzx r9d, BYTE PTR [rdi+43]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 22", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+44]", - "movzx r9d, BYTE PTR [rdi+45]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 23", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+46]", - "movzx r9d, BYTE PTR [rdi+47]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 24", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+48]", - "movzx r9d, BYTE PTR [rdi+49]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 25", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+50]", - "movzx r9d, BYTE PTR [rdi+51]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 26", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+52]", - "movzx r9d, BYTE PTR [rdi+53]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 27", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+54]", - "movzx r9d, BYTE PTR [rdi+55]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 28", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+56]", - "movzx r9d, BYTE PTR [rdi+57]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 29", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+58]", - "movzx r9d, BYTE PTR [rdi+59]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 30", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+60]", - "movzx r9d, BYTE PTR [rdi+61]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 31", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+62]", - "movzx r9d, BYTE PTR [rdi+63]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 32", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+64]", - "movzx r9d, BYTE PTR [rdi+65]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 33", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+66]", - "movzx r9d, BYTE PTR [rdi+67]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 34", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+68]", - "movzx r9d, BYTE PTR [rdi+69]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 35", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+70]", - "movzx r9d, BYTE PTR [rdi+71]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 36", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+72]", - "movzx r9d, BYTE PTR [rdi+73]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 37", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+74]", - "movzx r9d, BYTE PTR [rdi+75]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 38", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+76]", - "movzx r9d, BYTE PTR [rdi+77]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 39", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+78]", - "movzx r9d, BYTE PTR [rdi+79]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 40", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+80]", - "movzx r9d, BYTE PTR [rdi+81]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 41", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+82]", - "movzx r9d, BYTE PTR [rdi+83]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 42", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+84]", - "movzx r9d, BYTE PTR [rdi+85]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 43", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+86]", - "movzx r9d, BYTE PTR [rdi+87]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 44", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+88]", - "movzx r9d, BYTE PTR [rdi+89]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 45", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+90]", - "movzx r9d, BYTE PTR [rdi+91]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 46", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+92]", - "movzx r9d, BYTE PTR [rdi+93]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 47", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+94]", - "movzx r9d, BYTE PTR [rdi+95]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 48", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+96]", - "movzx r9d, BYTE PTR [rdi+97]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 49", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+98]", - "movzx r9d, BYTE PTR [rdi+99]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 50", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+100]", - "movzx r9d, BYTE PTR [rdi+101]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 51", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+102]", - "movzx r9d, BYTE PTR [rdi+103]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 52", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+104]", - "movzx r9d, BYTE PTR [rdi+105]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 53", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+106]", - "movzx r9d, BYTE PTR [rdi+107]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 54", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+108]", - "movzx r9d, BYTE PTR [rdi+109]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 55", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+110]", - "movzx r9d, BYTE PTR [rdi+111]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 56", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+112]", - "movzx r9d, BYTE PTR [rdi+113]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 57", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+114]", - "movzx r9d, BYTE PTR [rdi+115]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 58", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+116]", - "movzx r9d, BYTE PTR [rdi+117]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 59", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+118]", - "movzx r9d, BYTE PTR [rdi+119]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 60", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+120]", - "movzx r9d, BYTE PTR [rdi+121]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 61", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+122]", - "movzx r9d, BYTE PTR [rdi+123]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 62", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+124]", - "movzx r9d, BYTE PTR [rdi+125]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 63", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+126]", - "movzx r9d, BYTE PTR [rdi+127]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov rax, rcx", - "add r13, rax", - "and r13, 65535", - "mov rax, r13", - "and rax, 63", - "mov rcx, 0", - "mov r10, rax", - "xor r10, 0", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi]", - "movzx r9d, BYTE PTR [rdi+1]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 1", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+2]", - "movzx r9d, BYTE PTR [rdi+3]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 2", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+4]", - "movzx r9d, BYTE PTR [rdi+5]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 3", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+6]", - "movzx r9d, BYTE PTR [rdi+7]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 4", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+8]", - "movzx r9d, BYTE PTR [rdi+9]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 5", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+10]", - "movzx r9d, BYTE PTR [rdi+11]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 6", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+12]", - "movzx r9d, BYTE PTR [rdi+13]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 7", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+14]", - "movzx r9d, BYTE PTR [rdi+15]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 8", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+16]", - "movzx r9d, BYTE PTR [rdi+17]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 9", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+18]", - "movzx r9d, BYTE PTR [rdi+19]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 10", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+20]", - "movzx r9d, BYTE PTR [rdi+21]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 11", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+22]", - "movzx r9d, BYTE PTR [rdi+23]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 12", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+24]", - "movzx r9d, BYTE PTR [rdi+25]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 13", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+26]", - "movzx r9d, BYTE PTR [rdi+27]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 14", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+28]", - "movzx r9d, BYTE PTR [rdi+29]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 15", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+30]", - "movzx r9d, BYTE PTR [rdi+31]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 16", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+32]", - "movzx r9d, BYTE PTR [rdi+33]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 17", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+34]", - "movzx r9d, BYTE PTR [rdi+35]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 18", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+36]", - "movzx r9d, BYTE PTR [rdi+37]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 19", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+38]", - "movzx r9d, BYTE PTR [rdi+39]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 20", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+40]", - "movzx r9d, BYTE PTR [rdi+41]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 21", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+42]", - "movzx r9d, BYTE PTR [rdi+43]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 22", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+44]", - "movzx r9d, BYTE PTR [rdi+45]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 23", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+46]", - "movzx r9d, BYTE PTR [rdi+47]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 24", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+48]", - "movzx r9d, BYTE PTR [rdi+49]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 25", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+50]", - "movzx r9d, BYTE PTR [rdi+51]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 26", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+52]", - "movzx r9d, BYTE PTR [rdi+53]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 27", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+54]", - "movzx r9d, BYTE PTR [rdi+55]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 28", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+56]", - "movzx r9d, BYTE PTR [rdi+57]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 29", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+58]", - "movzx r9d, BYTE PTR [rdi+59]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 30", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+60]", - "movzx r9d, BYTE PTR [rdi+61]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 31", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+62]", - "movzx r9d, BYTE PTR [rdi+63]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 32", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+64]", - "movzx r9d, BYTE PTR [rdi+65]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 33", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+66]", - "movzx r9d, BYTE PTR [rdi+67]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 34", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+68]", - "movzx r9d, BYTE PTR [rdi+69]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 35", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+70]", - "movzx r9d, BYTE PTR [rdi+71]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 36", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+72]", - "movzx r9d, BYTE PTR [rdi+73]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 37", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+74]", - "movzx r9d, BYTE PTR [rdi+75]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 38", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+76]", - "movzx r9d, BYTE PTR [rdi+77]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 39", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+78]", - "movzx r9d, BYTE PTR [rdi+79]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 40", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+80]", - "movzx r9d, BYTE PTR [rdi+81]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 41", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+82]", - "movzx r9d, BYTE PTR [rdi+83]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 42", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+84]", - "movzx r9d, BYTE PTR [rdi+85]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 43", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+86]", - "movzx r9d, BYTE PTR [rdi+87]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 44", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+88]", - "movzx r9d, BYTE PTR [rdi+89]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 45", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+90]", - "movzx r9d, BYTE PTR [rdi+91]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 46", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+92]", - "movzx r9d, BYTE PTR [rdi+93]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 47", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+94]", - "movzx r9d, BYTE PTR [rdi+95]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 48", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+96]", - "movzx r9d, BYTE PTR [rdi+97]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 49", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+98]", - "movzx r9d, BYTE PTR [rdi+99]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 50", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+100]", - "movzx r9d, BYTE PTR [rdi+101]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 51", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+102]", - "movzx r9d, BYTE PTR [rdi+103]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 52", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+104]", - "movzx r9d, BYTE PTR [rdi+105]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 53", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+106]", - "movzx r9d, BYTE PTR [rdi+107]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 54", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+108]", - "movzx r9d, BYTE PTR [rdi+109]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 55", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+110]", - "movzx r9d, BYTE PTR [rdi+111]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 56", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+112]", - "movzx r9d, BYTE PTR [rdi+113]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 57", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+114]", - "movzx r9d, BYTE PTR [rdi+115]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 58", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+116]", - "movzx r9d, BYTE PTR [rdi+117]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 59", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+118]", - "movzx r9d, BYTE PTR [rdi+119]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 60", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+120]", - "movzx r9d, BYTE PTR [rdi+121]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 61", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+122]", - "movzx r9d, BYTE PTR [rdi+123]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 62", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+124]", - "movzx r9d, BYTE PTR [rdi+125]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 63", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+126]", - "movzx r9d, BYTE PTR [rdi+127]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov rax, rcx", - "add r14, rax", - "and r14, 65535", - "mov rax, r14", - "and rax, 63", - "mov rcx, 0", - "mov r10, rax", - "xor r10, 0", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi]", - "movzx r9d, BYTE PTR [rdi+1]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 1", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+2]", - "movzx r9d, BYTE PTR [rdi+3]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 2", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+4]", - "movzx r9d, BYTE PTR [rdi+5]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 3", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+6]", - "movzx r9d, BYTE PTR [rdi+7]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 4", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+8]", - "movzx r9d, BYTE PTR [rdi+9]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 5", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+10]", - "movzx r9d, BYTE PTR [rdi+11]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 6", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+12]", - "movzx r9d, BYTE PTR [rdi+13]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 7", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+14]", - "movzx r9d, BYTE PTR [rdi+15]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 8", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+16]", - "movzx r9d, BYTE PTR [rdi+17]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 9", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+18]", - "movzx r9d, BYTE PTR [rdi+19]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 10", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+20]", - "movzx r9d, BYTE PTR [rdi+21]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 11", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+22]", - "movzx r9d, BYTE PTR [rdi+23]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 12", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+24]", - "movzx r9d, BYTE PTR [rdi+25]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 13", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+26]", - "movzx r9d, BYTE PTR [rdi+27]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 14", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+28]", - "movzx r9d, BYTE PTR [rdi+29]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 15", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+30]", - "movzx r9d, BYTE PTR [rdi+31]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 16", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+32]", - "movzx r9d, BYTE PTR [rdi+33]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 17", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+34]", - "movzx r9d, BYTE PTR [rdi+35]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 18", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+36]", - "movzx r9d, BYTE PTR [rdi+37]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 19", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+38]", - "movzx r9d, BYTE PTR [rdi+39]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 20", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+40]", - "movzx r9d, BYTE PTR [rdi+41]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 21", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+42]", - "movzx r9d, BYTE PTR [rdi+43]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 22", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+44]", - "movzx r9d, BYTE PTR [rdi+45]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 23", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+46]", - "movzx r9d, BYTE PTR [rdi+47]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 24", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+48]", - "movzx r9d, BYTE PTR [rdi+49]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 25", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+50]", - "movzx r9d, BYTE PTR [rdi+51]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 26", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+52]", - "movzx r9d, BYTE PTR [rdi+53]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 27", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+54]", - "movzx r9d, BYTE PTR [rdi+55]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 28", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+56]", - "movzx r9d, BYTE PTR [rdi+57]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 29", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+58]", - "movzx r9d, BYTE PTR [rdi+59]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 30", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+60]", - "movzx r9d, BYTE PTR [rdi+61]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 31", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+62]", - "movzx r9d, BYTE PTR [rdi+63]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 32", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+64]", - "movzx r9d, BYTE PTR [rdi+65]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 33", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+66]", - "movzx r9d, BYTE PTR [rdi+67]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 34", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+68]", - "movzx r9d, BYTE PTR [rdi+69]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 35", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+70]", - "movzx r9d, BYTE PTR [rdi+71]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 36", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+72]", - "movzx r9d, BYTE PTR [rdi+73]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 37", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+74]", - "movzx r9d, BYTE PTR [rdi+75]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 38", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+76]", - "movzx r9d, BYTE PTR [rdi+77]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 39", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+78]", - "movzx r9d, BYTE PTR [rdi+79]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 40", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+80]", - "movzx r9d, BYTE PTR [rdi+81]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 41", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+82]", - "movzx r9d, BYTE PTR [rdi+83]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 42", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+84]", - "movzx r9d, BYTE PTR [rdi+85]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 43", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+86]", - "movzx r9d, BYTE PTR [rdi+87]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 44", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+88]", - "movzx r9d, BYTE PTR [rdi+89]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 45", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+90]", - "movzx r9d, BYTE PTR [rdi+91]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 46", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+92]", - "movzx r9d, BYTE PTR [rdi+93]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 47", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+94]", - "movzx r9d, BYTE PTR [rdi+95]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 48", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+96]", - "movzx r9d, BYTE PTR [rdi+97]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 49", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+98]", - "movzx r9d, BYTE PTR [rdi+99]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 50", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+100]", - "movzx r9d, BYTE PTR [rdi+101]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 51", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+102]", - "movzx r9d, BYTE PTR [rdi+103]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 52", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+104]", - "movzx r9d, BYTE PTR [rdi+105]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 53", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+106]", - "movzx r9d, BYTE PTR [rdi+107]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 54", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+108]", - "movzx r9d, BYTE PTR [rdi+109]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 55", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+110]", - "movzx r9d, BYTE PTR [rdi+111]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 56", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+112]", - "movzx r9d, BYTE PTR [rdi+113]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 57", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+114]", - "movzx r9d, BYTE PTR [rdi+115]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 58", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+116]", - "movzx r9d, BYTE PTR [rdi+117]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 59", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+118]", - "movzx r9d, BYTE PTR [rdi+119]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 60", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+120]", - "movzx r9d, BYTE PTR [rdi+121]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 61", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+122]", - "movzx r9d, BYTE PTR [rdi+123]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 62", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+124]", - "movzx r9d, BYTE PTR [rdi+125]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 63", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+126]", - "movzx r9d, BYTE PTR [rdi+127]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov rax, rcx", - "add r15, rax", - "and r15, 65535", - "mov r10, r15", - "and r10, r14", - "mov r11, r15", - "xor r11, -1", - "and r11, r13", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+40]", - "movzx r9d, BYTE PTR [rdi+41]", - "ror r9, 56", - "or r8, r9", - "add r12, r8", - "add r12, r10", - "and r12, 65535", - "mov rax, r12", - "shr rax, 15", - "ror r12, 63", - "or r12, rax", - "and r12, 65535", - "mov r10, r12", - "and r10, r15", - "mov r11, r12", - "xor r11, -1", - "and r11, r14", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+42]", - "movzx r9d, BYTE PTR [rdi+43]", - "ror r9, 56", - "or r8, r9", - "add r13, r8", - "add r13, r10", - "and r13, 65535", - "mov rax, r13", - "shr rax, 14", - "ror r13, 62", - "or r13, rax", - "and r13, 65535", - "mov r10, r13", - "and r10, r12", - "mov r11, r13", - "xor r11, -1", - "and r11, r15", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+44]", - "movzx r9d, BYTE PTR [rdi+45]", - "ror r9, 56", - "or r8, r9", - "add r14, r8", - "add r14, r10", - "and r14, 65535", - "mov rax, r14", - "shr rax, 13", - "ror r14, 61", - "or r14, rax", - "and r14, 65535", - "mov r10, r14", - "and r10, r13", - "mov r11, r14", - "xor r11, -1", - "and r11, r12", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+46]", - "movzx r9d, BYTE PTR [rdi+47]", - "ror r9, 56", - "or r8, r9", - "add r15, r8", - "add r15, r10", - "and r15, 65535", - "mov rax, r15", - "shr rax, 11", - "ror r15, 59", - "or r15, rax", - "and r15, 65535", - "mov r10, r15", - "and r10, r14", - "mov r11, r15", - "xor r11, -1", - "and r11, r13", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+48]", - "movzx r9d, BYTE PTR [rdi+49]", - "ror r9, 56", - "or r8, r9", - "add r12, r8", - "add r12, r10", - "and r12, 65535", - "mov rax, r12", - "shr rax, 15", - "ror r12, 63", - "or r12, rax", - "and r12, 65535", - "mov r10, r12", - "and r10, r15", - "mov r11, r12", - "xor r11, -1", - "and r11, r14", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+50]", - "movzx r9d, BYTE PTR [rdi+51]", - "ror r9, 56", - "or r8, r9", - "add r13, r8", - "add r13, r10", - "and r13, 65535", - "mov rax, r13", - "shr rax, 14", - "ror r13, 62", - "or r13, rax", - "and r13, 65535", - "mov r10, r13", - "and r10, r12", - "mov r11, r13", - "xor r11, -1", - "and r11, r15", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+52]", - "movzx r9d, BYTE PTR [rdi+53]", - "ror r9, 56", - "or r8, r9", - "add r14, r8", - "add r14, r10", - "and r14, 65535", - "mov rax, r14", - "shr rax, 13", - "ror r14, 61", - "or r14, rax", - "and r14, 65535", - "mov r10, r14", - "and r10, r13", - "mov r11, r14", - "xor r11, -1", - "and r11, r12", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+54]", - "movzx r9d, BYTE PTR [rdi+55]", - "ror r9, 56", - "or r8, r9", - "add r15, r8", - "add r15, r10", - "and r15, 65535", - "mov rax, r15", - "shr rax, 11", - "ror r15, 59", - "or r15, rax", - "and r15, 65535", - "mov r10, r15", - "and r10, r14", - "mov r11, r15", - "xor r11, -1", - "and r11, r13", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+56]", - "movzx r9d, BYTE PTR [rdi+57]", - "ror r9, 56", - "or r8, r9", - "add r12, r8", - "add r12, r10", - "and r12, 65535", - "mov rax, r12", - "shr rax, 15", - "ror r12, 63", - "or r12, rax", - "and r12, 65535", - "mov r10, r12", - "and r10, r15", - "mov r11, r12", - "xor r11, -1", - "and r11, r14", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+58]", - "movzx r9d, BYTE PTR [rdi+59]", - "ror r9, 56", - "or r8, r9", - "add r13, r8", - "add r13, r10", - "and r13, 65535", - "mov rax, r13", - "shr rax, 14", - "ror r13, 62", - "or r13, rax", - "and r13, 65535", - "mov r10, r13", - "and r10, r12", - "mov r11, r13", - "xor r11, -1", - "and r11, r15", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+60]", - "movzx r9d, BYTE PTR [rdi+61]", - "ror r9, 56", - "or r8, r9", - "add r14, r8", - "add r14, r10", - "and r14, 65535", - "mov rax, r14", - "shr rax, 13", - "ror r14, 61", - "or r14, rax", - "and r14, 65535", - "mov r10, r14", - "and r10, r13", - "mov r11, r14", - "xor r11, -1", - "and r11, r12", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+62]", - "movzx r9d, BYTE PTR [rdi+63]", - "ror r9, 56", - "or r8, r9", - "add r15, r8", - "add r15, r10", - "and r15, 65535", - "mov rax, r15", - "shr rax, 11", - "ror r15, 59", - "or r15, rax", - "and r15, 65535", - "mov r10, r15", - "and r10, r14", - "mov r11, r15", - "xor r11, -1", - "and r11, r13", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+64]", - "movzx r9d, BYTE PTR [rdi+65]", - "ror r9, 56", - "or r8, r9", - "add r12, r8", - "add r12, r10", - "and r12, 65535", - "mov rax, r12", - "shr rax, 15", - "ror r12, 63", - "or r12, rax", - "and r12, 65535", - "mov r10, r12", - "and r10, r15", - "mov r11, r12", - "xor r11, -1", - "and r11, r14", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+66]", - "movzx r9d, BYTE PTR [rdi+67]", - "ror r9, 56", - "or r8, r9", - "add r13, r8", - "add r13, r10", - "and r13, 65535", - "mov rax, r13", - "shr rax, 14", - "ror r13, 62", - "or r13, rax", - "and r13, 65535", - "mov r10, r13", - "and r10, r12", - "mov r11, r13", - "xor r11, -1", - "and r11, r15", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+68]", - "movzx r9d, BYTE PTR [rdi+69]", - "ror r9, 56", - "or r8, r9", - "add r14, r8", - "add r14, r10", - "and r14, 65535", - "mov rax, r14", - "shr rax, 13", - "ror r14, 61", - "or r14, rax", - "and r14, 65535", - "mov r10, r14", - "and r10, r13", - "mov r11, r14", - "xor r11, -1", - "and r11, r12", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+70]", - "movzx r9d, BYTE PTR [rdi+71]", - "ror r9, 56", - "or r8, r9", - "add r15, r8", - "add r15, r10", - "and r15, 65535", - "mov rax, r15", - "shr rax, 11", - "ror r15, 59", - "or r15, rax", - "and r15, 65535", - "mov r10, r15", - "and r10, r14", - "mov r11, r15", - "xor r11, -1", - "and r11, r13", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+72]", - "movzx r9d, BYTE PTR [rdi+73]", - "ror r9, 56", - "or r8, r9", - "add r12, r8", - "add r12, r10", - "and r12, 65535", - "mov rax, r12", - "shr rax, 15", - "ror r12, 63", - "or r12, rax", - "and r12, 65535", - "mov r10, r12", - "and r10, r15", - "mov r11, r12", - "xor r11, -1", - "and r11, r14", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+74]", - "movzx r9d, BYTE PTR [rdi+75]", - "ror r9, 56", - "or r8, r9", - "add r13, r8", - "add r13, r10", - "and r13, 65535", - "mov rax, r13", - "shr rax, 14", - "ror r13, 62", - "or r13, rax", - "and r13, 65535", - "mov r10, r13", - "and r10, r12", - "mov r11, r13", - "xor r11, -1", - "and r11, r15", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+76]", - "movzx r9d, BYTE PTR [rdi+77]", - "ror r9, 56", - "or r8, r9", - "add r14, r8", - "add r14, r10", - "and r14, 65535", - "mov rax, r14", - "shr rax, 13", - "ror r14, 61", - "or r14, rax", - "and r14, 65535", - "mov r10, r14", - "and r10, r13", - "mov r11, r14", - "xor r11, -1", - "and r11, r12", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+78]", - "movzx r9d, BYTE PTR [rdi+79]", - "ror r9, 56", - "or r8, r9", - "add r15, r8", - "add r15, r10", - "and r15, 65535", - "mov rax, r15", - "shr rax, 11", - "ror r15, 59", - "or r15, rax", - "and r15, 65535", - "mov r10, r15", - "and r10, r14", - "mov r11, r15", - "xor r11, -1", - "and r11, r13", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+80]", - "movzx r9d, BYTE PTR [rdi+81]", - "ror r9, 56", - "or r8, r9", - "add r12, r8", - "add r12, r10", - "and r12, 65535", - "mov rax, r12", - "shr rax, 15", - "ror r12, 63", - "or r12, rax", - "and r12, 65535", - "mov r10, r12", - "and r10, r15", - "mov r11, r12", - "xor r11, -1", - "and r11, r14", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+82]", - "movzx r9d, BYTE PTR [rdi+83]", - "ror r9, 56", - "or r8, r9", - "add r13, r8", - "add r13, r10", - "and r13, 65535", - "mov rax, r13", - "shr rax, 14", - "ror r13, 62", - "or r13, rax", - "and r13, 65535", - "mov r10, r13", - "and r10, r12", - "mov r11, r13", - "xor r11, -1", - "and r11, r15", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+84]", - "movzx r9d, BYTE PTR [rdi+85]", - "ror r9, 56", - "or r8, r9", - "add r14, r8", - "add r14, r10", - "and r14, 65535", - "mov rax, r14", - "shr rax, 13", - "ror r14, 61", - "or r14, rax", - "and r14, 65535", - "mov r10, r14", - "and r10, r13", - "mov r11, r14", - "xor r11, -1", - "and r11, r12", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+86]", - "movzx r9d, BYTE PTR [rdi+87]", - "ror r9, 56", - "or r8, r9", - "add r15, r8", - "add r15, r10", - "and r15, 65535", - "mov rax, r15", - "shr rax, 11", - "ror r15, 59", - "or r15, rax", - "and r15, 65535", - "mov rax, r15", - "and rax, 63", - "mov rcx, 0", - "mov r10, rax", - "xor r10, 0", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi]", - "movzx r9d, BYTE PTR [rdi+1]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 1", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+2]", - "movzx r9d, BYTE PTR [rdi+3]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 2", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+4]", - "movzx r9d, BYTE PTR [rdi+5]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 3", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+6]", - "movzx r9d, BYTE PTR [rdi+7]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 4", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+8]", - "movzx r9d, BYTE PTR [rdi+9]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 5", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+10]", - "movzx r9d, BYTE PTR [rdi+11]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 6", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+12]", - "movzx r9d, BYTE PTR [rdi+13]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 7", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+14]", - "movzx r9d, BYTE PTR [rdi+15]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 8", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+16]", - "movzx r9d, BYTE PTR [rdi+17]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 9", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+18]", - "movzx r9d, BYTE PTR [rdi+19]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 10", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+20]", - "movzx r9d, BYTE PTR [rdi+21]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 11", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+22]", - "movzx r9d, BYTE PTR [rdi+23]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 12", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+24]", - "movzx r9d, BYTE PTR [rdi+25]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 13", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+26]", - "movzx r9d, BYTE PTR [rdi+27]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 14", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+28]", - "movzx r9d, BYTE PTR [rdi+29]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 15", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+30]", - "movzx r9d, BYTE PTR [rdi+31]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 16", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+32]", - "movzx r9d, BYTE PTR [rdi+33]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 17", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+34]", - "movzx r9d, BYTE PTR [rdi+35]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 18", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+36]", - "movzx r9d, BYTE PTR [rdi+37]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 19", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+38]", - "movzx r9d, BYTE PTR [rdi+39]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 20", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+40]", - "movzx r9d, BYTE PTR [rdi+41]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 21", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+42]", - "movzx r9d, BYTE PTR [rdi+43]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 22", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+44]", - "movzx r9d, BYTE PTR [rdi+45]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 23", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+46]", - "movzx r9d, BYTE PTR [rdi+47]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 24", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+48]", - "movzx r9d, BYTE PTR [rdi+49]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 25", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+50]", - "movzx r9d, BYTE PTR [rdi+51]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 26", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+52]", - "movzx r9d, BYTE PTR [rdi+53]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 27", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+54]", - "movzx r9d, BYTE PTR [rdi+55]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 28", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+56]", - "movzx r9d, BYTE PTR [rdi+57]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 29", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+58]", - "movzx r9d, BYTE PTR [rdi+59]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 30", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+60]", - "movzx r9d, BYTE PTR [rdi+61]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 31", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+62]", - "movzx r9d, BYTE PTR [rdi+63]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 32", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+64]", - "movzx r9d, BYTE PTR [rdi+65]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 33", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+66]", - "movzx r9d, BYTE PTR [rdi+67]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 34", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+68]", - "movzx r9d, BYTE PTR [rdi+69]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 35", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+70]", - "movzx r9d, BYTE PTR [rdi+71]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 36", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+72]", - "movzx r9d, BYTE PTR [rdi+73]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 37", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+74]", - "movzx r9d, BYTE PTR [rdi+75]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 38", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+76]", - "movzx r9d, BYTE PTR [rdi+77]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 39", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+78]", - "movzx r9d, BYTE PTR [rdi+79]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 40", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+80]", - "movzx r9d, BYTE PTR [rdi+81]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 41", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+82]", - "movzx r9d, BYTE PTR [rdi+83]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 42", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+84]", - "movzx r9d, BYTE PTR [rdi+85]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 43", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+86]", - "movzx r9d, BYTE PTR [rdi+87]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 44", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+88]", - "movzx r9d, BYTE PTR [rdi+89]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 45", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+90]", - "movzx r9d, BYTE PTR [rdi+91]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 46", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+92]", - "movzx r9d, BYTE PTR [rdi+93]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 47", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+94]", - "movzx r9d, BYTE PTR [rdi+95]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 48", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+96]", - "movzx r9d, BYTE PTR [rdi+97]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 49", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+98]", - "movzx r9d, BYTE PTR [rdi+99]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 50", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+100]", - "movzx r9d, BYTE PTR [rdi+101]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 51", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+102]", - "movzx r9d, BYTE PTR [rdi+103]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 52", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+104]", - "movzx r9d, BYTE PTR [rdi+105]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 53", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+106]", - "movzx r9d, BYTE PTR [rdi+107]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 54", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+108]", - "movzx r9d, BYTE PTR [rdi+109]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 55", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+110]", - "movzx r9d, BYTE PTR [rdi+111]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 56", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+112]", - "movzx r9d, BYTE PTR [rdi+113]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 57", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+114]", - "movzx r9d, BYTE PTR [rdi+115]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 58", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+116]", - "movzx r9d, BYTE PTR [rdi+117]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 59", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+118]", - "movzx r9d, BYTE PTR [rdi+119]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 60", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+120]", - "movzx r9d, BYTE PTR [rdi+121]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 61", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+122]", - "movzx r9d, BYTE PTR [rdi+123]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 62", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+124]", - "movzx r9d, BYTE PTR [rdi+125]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 63", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+126]", - "movzx r9d, BYTE PTR [rdi+127]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov rax, rcx", - "add r12, rax", - "and r12, 65535", - "mov rax, r12", - "and rax, 63", - "mov rcx, 0", - "mov r10, rax", - "xor r10, 0", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi]", - "movzx r9d, BYTE PTR [rdi+1]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 1", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+2]", - "movzx r9d, BYTE PTR [rdi+3]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 2", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+4]", - "movzx r9d, BYTE PTR [rdi+5]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 3", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+6]", - "movzx r9d, BYTE PTR [rdi+7]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 4", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+8]", - "movzx r9d, BYTE PTR [rdi+9]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 5", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+10]", - "movzx r9d, BYTE PTR [rdi+11]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 6", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+12]", - "movzx r9d, BYTE PTR [rdi+13]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 7", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+14]", - "movzx r9d, BYTE PTR [rdi+15]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 8", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+16]", - "movzx r9d, BYTE PTR [rdi+17]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 9", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+18]", - "movzx r9d, BYTE PTR [rdi+19]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 10", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+20]", - "movzx r9d, BYTE PTR [rdi+21]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 11", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+22]", - "movzx r9d, BYTE PTR [rdi+23]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 12", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+24]", - "movzx r9d, BYTE PTR [rdi+25]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 13", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+26]", - "movzx r9d, BYTE PTR [rdi+27]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 14", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+28]", - "movzx r9d, BYTE PTR [rdi+29]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 15", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+30]", - "movzx r9d, BYTE PTR [rdi+31]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 16", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+32]", - "movzx r9d, BYTE PTR [rdi+33]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 17", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+34]", - "movzx r9d, BYTE PTR [rdi+35]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 18", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+36]", - "movzx r9d, BYTE PTR [rdi+37]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 19", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+38]", - "movzx r9d, BYTE PTR [rdi+39]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 20", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+40]", - "movzx r9d, BYTE PTR [rdi+41]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 21", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+42]", - "movzx r9d, BYTE PTR [rdi+43]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 22", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+44]", - "movzx r9d, BYTE PTR [rdi+45]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 23", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+46]", - "movzx r9d, BYTE PTR [rdi+47]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 24", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+48]", - "movzx r9d, BYTE PTR [rdi+49]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 25", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+50]", - "movzx r9d, BYTE PTR [rdi+51]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 26", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+52]", - "movzx r9d, BYTE PTR [rdi+53]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 27", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+54]", - "movzx r9d, BYTE PTR [rdi+55]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 28", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+56]", - "movzx r9d, BYTE PTR [rdi+57]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 29", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+58]", - "movzx r9d, BYTE PTR [rdi+59]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 30", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+60]", - "movzx r9d, BYTE PTR [rdi+61]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 31", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+62]", - "movzx r9d, BYTE PTR [rdi+63]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 32", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+64]", - "movzx r9d, BYTE PTR [rdi+65]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 33", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+66]", - "movzx r9d, BYTE PTR [rdi+67]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 34", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+68]", - "movzx r9d, BYTE PTR [rdi+69]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 35", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+70]", - "movzx r9d, BYTE PTR [rdi+71]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 36", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+72]", - "movzx r9d, BYTE PTR [rdi+73]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 37", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+74]", - "movzx r9d, BYTE PTR [rdi+75]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 38", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+76]", - "movzx r9d, BYTE PTR [rdi+77]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 39", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+78]", - "movzx r9d, BYTE PTR [rdi+79]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 40", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+80]", - "movzx r9d, BYTE PTR [rdi+81]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 41", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+82]", - "movzx r9d, BYTE PTR [rdi+83]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 42", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+84]", - "movzx r9d, BYTE PTR [rdi+85]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 43", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+86]", - "movzx r9d, BYTE PTR [rdi+87]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 44", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+88]", - "movzx r9d, BYTE PTR [rdi+89]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 45", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+90]", - "movzx r9d, BYTE PTR [rdi+91]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 46", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+92]", - "movzx r9d, BYTE PTR [rdi+93]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 47", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+94]", - "movzx r9d, BYTE PTR [rdi+95]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 48", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+96]", - "movzx r9d, BYTE PTR [rdi+97]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 49", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+98]", - "movzx r9d, BYTE PTR [rdi+99]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 50", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+100]", - "movzx r9d, BYTE PTR [rdi+101]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 51", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+102]", - "movzx r9d, BYTE PTR [rdi+103]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 52", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+104]", - "movzx r9d, BYTE PTR [rdi+105]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 53", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+106]", - "movzx r9d, BYTE PTR [rdi+107]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 54", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+108]", - "movzx r9d, BYTE PTR [rdi+109]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 55", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+110]", - "movzx r9d, BYTE PTR [rdi+111]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 56", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+112]", - "movzx r9d, BYTE PTR [rdi+113]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 57", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+114]", - "movzx r9d, BYTE PTR [rdi+115]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 58", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+116]", - "movzx r9d, BYTE PTR [rdi+117]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 59", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+118]", - "movzx r9d, BYTE PTR [rdi+119]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 60", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+120]", - "movzx r9d, BYTE PTR [rdi+121]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 61", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+122]", - "movzx r9d, BYTE PTR [rdi+123]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 62", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+124]", - "movzx r9d, BYTE PTR [rdi+125]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 63", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+126]", - "movzx r9d, BYTE PTR [rdi+127]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov rax, rcx", - "add r13, rax", - "and r13, 65535", - "mov rax, r13", - "and rax, 63", - "mov rcx, 0", - "mov r10, rax", - "xor r10, 0", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi]", - "movzx r9d, BYTE PTR [rdi+1]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 1", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+2]", - "movzx r9d, BYTE PTR [rdi+3]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 2", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+4]", - "movzx r9d, BYTE PTR [rdi+5]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 3", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+6]", - "movzx r9d, BYTE PTR [rdi+7]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 4", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+8]", - "movzx r9d, BYTE PTR [rdi+9]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 5", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+10]", - "movzx r9d, BYTE PTR [rdi+11]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 6", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+12]", - "movzx r9d, BYTE PTR [rdi+13]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 7", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+14]", - "movzx r9d, BYTE PTR [rdi+15]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 8", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+16]", - "movzx r9d, BYTE PTR [rdi+17]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 9", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+18]", - "movzx r9d, BYTE PTR [rdi+19]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 10", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+20]", - "movzx r9d, BYTE PTR [rdi+21]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 11", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+22]", - "movzx r9d, BYTE PTR [rdi+23]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 12", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+24]", - "movzx r9d, BYTE PTR [rdi+25]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 13", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+26]", - "movzx r9d, BYTE PTR [rdi+27]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 14", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+28]", - "movzx r9d, BYTE PTR [rdi+29]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 15", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+30]", - "movzx r9d, BYTE PTR [rdi+31]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 16", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+32]", - "movzx r9d, BYTE PTR [rdi+33]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 17", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+34]", - "movzx r9d, BYTE PTR [rdi+35]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 18", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+36]", - "movzx r9d, BYTE PTR [rdi+37]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 19", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+38]", - "movzx r9d, BYTE PTR [rdi+39]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 20", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+40]", - "movzx r9d, BYTE PTR [rdi+41]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 21", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+42]", - "movzx r9d, BYTE PTR [rdi+43]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 22", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+44]", - "movzx r9d, BYTE PTR [rdi+45]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 23", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+46]", - "movzx r9d, BYTE PTR [rdi+47]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 24", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+48]", - "movzx r9d, BYTE PTR [rdi+49]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 25", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+50]", - "movzx r9d, BYTE PTR [rdi+51]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 26", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+52]", - "movzx r9d, BYTE PTR [rdi+53]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 27", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+54]", - "movzx r9d, BYTE PTR [rdi+55]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 28", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+56]", - "movzx r9d, BYTE PTR [rdi+57]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 29", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+58]", - "movzx r9d, BYTE PTR [rdi+59]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 30", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+60]", - "movzx r9d, BYTE PTR [rdi+61]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 31", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+62]", - "movzx r9d, BYTE PTR [rdi+63]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 32", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+64]", - "movzx r9d, BYTE PTR [rdi+65]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 33", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+66]", - "movzx r9d, BYTE PTR [rdi+67]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 34", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+68]", - "movzx r9d, BYTE PTR [rdi+69]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 35", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+70]", - "movzx r9d, BYTE PTR [rdi+71]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 36", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+72]", - "movzx r9d, BYTE PTR [rdi+73]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 37", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+74]", - "movzx r9d, BYTE PTR [rdi+75]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 38", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+76]", - "movzx r9d, BYTE PTR [rdi+77]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 39", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+78]", - "movzx r9d, BYTE PTR [rdi+79]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 40", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+80]", - "movzx r9d, BYTE PTR [rdi+81]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 41", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+82]", - "movzx r9d, BYTE PTR [rdi+83]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 42", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+84]", - "movzx r9d, BYTE PTR [rdi+85]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 43", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+86]", - "movzx r9d, BYTE PTR [rdi+87]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 44", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+88]", - "movzx r9d, BYTE PTR [rdi+89]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 45", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+90]", - "movzx r9d, BYTE PTR [rdi+91]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 46", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+92]", - "movzx r9d, BYTE PTR [rdi+93]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 47", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+94]", - "movzx r9d, BYTE PTR [rdi+95]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 48", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+96]", - "movzx r9d, BYTE PTR [rdi+97]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 49", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+98]", - "movzx r9d, BYTE PTR [rdi+99]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 50", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+100]", - "movzx r9d, BYTE PTR [rdi+101]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 51", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+102]", - "movzx r9d, BYTE PTR [rdi+103]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 52", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+104]", - "movzx r9d, BYTE PTR [rdi+105]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 53", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+106]", - "movzx r9d, BYTE PTR [rdi+107]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 54", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+108]", - "movzx r9d, BYTE PTR [rdi+109]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 55", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+110]", - "movzx r9d, BYTE PTR [rdi+111]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 56", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+112]", - "movzx r9d, BYTE PTR [rdi+113]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 57", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+114]", - "movzx r9d, BYTE PTR [rdi+115]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 58", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+116]", - "movzx r9d, BYTE PTR [rdi+117]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 59", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+118]", - "movzx r9d, BYTE PTR [rdi+119]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 60", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+120]", - "movzx r9d, BYTE PTR [rdi+121]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 61", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+122]", - "movzx r9d, BYTE PTR [rdi+123]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 62", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+124]", - "movzx r9d, BYTE PTR [rdi+125]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 63", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+126]", - "movzx r9d, BYTE PTR [rdi+127]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov rax, rcx", - "add r14, rax", - "and r14, 65535", - "mov rax, r14", - "and rax, 63", - "mov rcx, 0", - "mov r10, rax", - "xor r10, 0", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi]", - "movzx r9d, BYTE PTR [rdi+1]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 1", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+2]", - "movzx r9d, BYTE PTR [rdi+3]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 2", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+4]", - "movzx r9d, BYTE PTR [rdi+5]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 3", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+6]", - "movzx r9d, BYTE PTR [rdi+7]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 4", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+8]", - "movzx r9d, BYTE PTR [rdi+9]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 5", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+10]", - "movzx r9d, BYTE PTR [rdi+11]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 6", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+12]", - "movzx r9d, BYTE PTR [rdi+13]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 7", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+14]", - "movzx r9d, BYTE PTR [rdi+15]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 8", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+16]", - "movzx r9d, BYTE PTR [rdi+17]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 9", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+18]", - "movzx r9d, BYTE PTR [rdi+19]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 10", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+20]", - "movzx r9d, BYTE PTR [rdi+21]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 11", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+22]", - "movzx r9d, BYTE PTR [rdi+23]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 12", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+24]", - "movzx r9d, BYTE PTR [rdi+25]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 13", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+26]", - "movzx r9d, BYTE PTR [rdi+27]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 14", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+28]", - "movzx r9d, BYTE PTR [rdi+29]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 15", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+30]", - "movzx r9d, BYTE PTR [rdi+31]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 16", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+32]", - "movzx r9d, BYTE PTR [rdi+33]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 17", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+34]", - "movzx r9d, BYTE PTR [rdi+35]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 18", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+36]", - "movzx r9d, BYTE PTR [rdi+37]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 19", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+38]", - "movzx r9d, BYTE PTR [rdi+39]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 20", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+40]", - "movzx r9d, BYTE PTR [rdi+41]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 21", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+42]", - "movzx r9d, BYTE PTR [rdi+43]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 22", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+44]", - "movzx r9d, BYTE PTR [rdi+45]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 23", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+46]", - "movzx r9d, BYTE PTR [rdi+47]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 24", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+48]", - "movzx r9d, BYTE PTR [rdi+49]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 25", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+50]", - "movzx r9d, BYTE PTR [rdi+51]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 26", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+52]", - "movzx r9d, BYTE PTR [rdi+53]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 27", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+54]", - "movzx r9d, BYTE PTR [rdi+55]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 28", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+56]", - "movzx r9d, BYTE PTR [rdi+57]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 29", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+58]", - "movzx r9d, BYTE PTR [rdi+59]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 30", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+60]", - "movzx r9d, BYTE PTR [rdi+61]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 31", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+62]", - "movzx r9d, BYTE PTR [rdi+63]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 32", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+64]", - "movzx r9d, BYTE PTR [rdi+65]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 33", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+66]", - "movzx r9d, BYTE PTR [rdi+67]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 34", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+68]", - "movzx r9d, BYTE PTR [rdi+69]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 35", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+70]", - "movzx r9d, BYTE PTR [rdi+71]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 36", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+72]", - "movzx r9d, BYTE PTR [rdi+73]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 37", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+74]", - "movzx r9d, BYTE PTR [rdi+75]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 38", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+76]", - "movzx r9d, BYTE PTR [rdi+77]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 39", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+78]", - "movzx r9d, BYTE PTR [rdi+79]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 40", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+80]", - "movzx r9d, BYTE PTR [rdi+81]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 41", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+82]", - "movzx r9d, BYTE PTR [rdi+83]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 42", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+84]", - "movzx r9d, BYTE PTR [rdi+85]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 43", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+86]", - "movzx r9d, BYTE PTR [rdi+87]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 44", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+88]", - "movzx r9d, BYTE PTR [rdi+89]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 45", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+90]", - "movzx r9d, BYTE PTR [rdi+91]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 46", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+92]", - "movzx r9d, BYTE PTR [rdi+93]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 47", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+94]", - "movzx r9d, BYTE PTR [rdi+95]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 48", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+96]", - "movzx r9d, BYTE PTR [rdi+97]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 49", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+98]", - "movzx r9d, BYTE PTR [rdi+99]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 50", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+100]", - "movzx r9d, BYTE PTR [rdi+101]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 51", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+102]", - "movzx r9d, BYTE PTR [rdi+103]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 52", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+104]", - "movzx r9d, BYTE PTR [rdi+105]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 53", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+106]", - "movzx r9d, BYTE PTR [rdi+107]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 54", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+108]", - "movzx r9d, BYTE PTR [rdi+109]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 55", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+110]", - "movzx r9d, BYTE PTR [rdi+111]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 56", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+112]", - "movzx r9d, BYTE PTR [rdi+113]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 57", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+114]", - "movzx r9d, BYTE PTR [rdi+115]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 58", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+116]", - "movzx r9d, BYTE PTR [rdi+117]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 59", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+118]", - "movzx r9d, BYTE PTR [rdi+119]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 60", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+120]", - "movzx r9d, BYTE PTR [rdi+121]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 61", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+122]", - "movzx r9d, BYTE PTR [rdi+123]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 62", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+124]", - "movzx r9d, BYTE PTR [rdi+125]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 63", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+126]", - "movzx r9d, BYTE PTR [rdi+127]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov rax, rcx", - "add r15, rax", - "and r15, 65535", - "mov r10, r15", - "and r10, r14", - "mov r11, r15", - "xor r11, -1", - "and r11, r13", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+88]", - "movzx r9d, BYTE PTR [rdi+89]", - "ror r9, 56", - "or r8, r9", - "add r12, r8", - "add r12, r10", - "and r12, 65535", - "mov rax, r12", - "shr rax, 15", - "ror r12, 63", - "or r12, rax", - "and r12, 65535", - "mov r10, r12", - "and r10, r15", - "mov r11, r12", - "xor r11, -1", - "and r11, r14", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+90]", - "movzx r9d, BYTE PTR [rdi+91]", - "ror r9, 56", - "or r8, r9", - "add r13, r8", - "add r13, r10", - "and r13, 65535", - "mov rax, r13", - "shr rax, 14", - "ror r13, 62", - "or r13, rax", - "and r13, 65535", - "mov r10, r13", - "and r10, r12", - "mov r11, r13", - "xor r11, -1", - "and r11, r15", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+92]", - "movzx r9d, BYTE PTR [rdi+93]", - "ror r9, 56", - "or r8, r9", - "add r14, r8", - "add r14, r10", - "and r14, 65535", - "mov rax, r14", - "shr rax, 13", - "ror r14, 61", - "or r14, rax", - "and r14, 65535", - "mov r10, r14", - "and r10, r13", - "mov r11, r14", - "xor r11, -1", - "and r11, r12", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+94]", - "movzx r9d, BYTE PTR [rdi+95]", - "ror r9, 56", - "or r8, r9", - "add r15, r8", - "add r15, r10", - "and r15, 65535", - "mov rax, r15", - "shr rax, 11", - "ror r15, 59", - "or r15, rax", - "and r15, 65535", - "mov r10, r15", - "and r10, r14", - "mov r11, r15", - "xor r11, -1", - "and r11, r13", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+96]", - "movzx r9d, BYTE PTR [rdi+97]", - "ror r9, 56", - "or r8, r9", - "add r12, r8", - "add r12, r10", - "and r12, 65535", - "mov rax, r12", - "shr rax, 15", - "ror r12, 63", - "or r12, rax", - "and r12, 65535", - "mov r10, r12", - "and r10, r15", - "mov r11, r12", - "xor r11, -1", - "and r11, r14", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+98]", - "movzx r9d, BYTE PTR [rdi+99]", - "ror r9, 56", - "or r8, r9", - "add r13, r8", - "add r13, r10", - "and r13, 65535", - "mov rax, r13", - "shr rax, 14", - "ror r13, 62", - "or r13, rax", - "and r13, 65535", - "mov r10, r13", - "and r10, r12", - "mov r11, r13", - "xor r11, -1", - "and r11, r15", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+100]", - "movzx r9d, BYTE PTR [rdi+101]", - "ror r9, 56", - "or r8, r9", - "add r14, r8", - "add r14, r10", - "and r14, 65535", - "mov rax, r14", - "shr rax, 13", - "ror r14, 61", - "or r14, rax", - "and r14, 65535", - "mov r10, r14", - "and r10, r13", - "mov r11, r14", - "xor r11, -1", - "and r11, r12", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+102]", - "movzx r9d, BYTE PTR [rdi+103]", - "ror r9, 56", - "or r8, r9", - "add r15, r8", - "add r15, r10", - "and r15, 65535", - "mov rax, r15", - "shr rax, 11", - "ror r15, 59", - "or r15, rax", - "and r15, 65535", - "mov r10, r15", - "and r10, r14", - "mov r11, r15", - "xor r11, -1", - "and r11, r13", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+104]", - "movzx r9d, BYTE PTR [rdi+105]", - "ror r9, 56", - "or r8, r9", - "add r12, r8", - "add r12, r10", - "and r12, 65535", - "mov rax, r12", - "shr rax, 15", - "ror r12, 63", - "or r12, rax", - "and r12, 65535", - "mov r10, r12", - "and r10, r15", - "mov r11, r12", - "xor r11, -1", - "and r11, r14", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+106]", - "movzx r9d, BYTE PTR [rdi+107]", - "ror r9, 56", - "or r8, r9", - "add r13, r8", - "add r13, r10", - "and r13, 65535", - "mov rax, r13", - "shr rax, 14", - "ror r13, 62", - "or r13, rax", - "and r13, 65535", - "mov r10, r13", - "and r10, r12", - "mov r11, r13", - "xor r11, -1", - "and r11, r15", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+108]", - "movzx r9d, BYTE PTR [rdi+109]", - "ror r9, 56", - "or r8, r9", - "add r14, r8", - "add r14, r10", - "and r14, 65535", - "mov rax, r14", - "shr rax, 13", - "ror r14, 61", - "or r14, rax", - "and r14, 65535", - "mov r10, r14", - "and r10, r13", - "mov r11, r14", - "xor r11, -1", - "and r11, r12", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+110]", - "movzx r9d, BYTE PTR [rdi+111]", - "ror r9, 56", - "or r8, r9", - "add r15, r8", - "add r15, r10", - "and r15, 65535", - "mov rax, r15", - "shr rax, 11", - "ror r15, 59", - "or r15, rax", - "and r15, 65535", - "mov r10, r15", - "and r10, r14", - "mov r11, r15", - "xor r11, -1", - "and r11, r13", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+112]", - "movzx r9d, BYTE PTR [rdi+113]", - "ror r9, 56", - "or r8, r9", - "add r12, r8", - "add r12, r10", - "and r12, 65535", - "mov rax, r12", - "shr rax, 15", - "ror r12, 63", - "or r12, rax", - "and r12, 65535", - "mov r10, r12", - "and r10, r15", - "mov r11, r12", - "xor r11, -1", - "and r11, r14", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+114]", - "movzx r9d, BYTE PTR [rdi+115]", - "ror r9, 56", - "or r8, r9", - "add r13, r8", - "add r13, r10", - "and r13, 65535", - "mov rax, r13", - "shr rax, 14", - "ror r13, 62", - "or r13, rax", - "and r13, 65535", - "mov r10, r13", - "and r10, r12", - "mov r11, r13", - "xor r11, -1", - "and r11, r15", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+116]", - "movzx r9d, BYTE PTR [rdi+117]", - "ror r9, 56", - "or r8, r9", - "add r14, r8", - "add r14, r10", - "and r14, 65535", - "mov rax, r14", - "shr rax, 13", - "ror r14, 61", - "or r14, rax", - "and r14, 65535", - "mov r10, r14", - "and r10, r13", - "mov r11, r14", - "xor r11, -1", - "and r11, r12", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+118]", - "movzx r9d, BYTE PTR [rdi+119]", - "ror r9, 56", - "or r8, r9", - "add r15, r8", - "add r15, r10", - "and r15, 65535", - "mov rax, r15", - "shr rax, 11", - "ror r15, 59", - "or r15, rax", - "and r15, 65535", - "mov r10, r15", - "and r10, r14", - "mov r11, r15", - "xor r11, -1", - "and r11, r13", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+120]", - "movzx r9d, BYTE PTR [rdi+121]", - "ror r9, 56", - "or r8, r9", - "add r12, r8", - "add r12, r10", - "and r12, 65535", - "mov rax, r12", - "shr rax, 15", - "ror r12, 63", - "or r12, rax", - "and r12, 65535", - "mov r10, r12", - "and r10, r15", - "mov r11, r12", - "xor r11, -1", - "and r11, r14", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+122]", - "movzx r9d, BYTE PTR [rdi+123]", - "ror r9, 56", - "or r8, r9", - "add r13, r8", - "add r13, r10", - "and r13, 65535", - "mov rax, r13", - "shr rax, 14", - "ror r13, 62", - "or r13, rax", - "and r13, 65535", - "mov r10, r13", - "and r10, r12", - "mov r11, r13", - "xor r11, -1", - "and r11, r15", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+124]", - "movzx r9d, BYTE PTR [rdi+125]", - "ror r9, 56", - "or r8, r9", - "add r14, r8", - "add r14, r10", - "and r14, 65535", - "mov rax, r14", - "shr rax, 13", - "ror r14, 61", - "or r14, rax", - "and r14, 65535", - "mov r10, r14", - "and r10, r13", - "mov r11, r14", - "xor r11, -1", - "and r11, r12", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+126]", - "movzx r9d, BYTE PTR [rdi+127]", - "ror r9, 56", - "or r8, r9", - "add r15, r8", - "add r15, r10", - "and r15, 65535", - "mov rax, r15", - "shr rax, 11", - "ror r15, 59", - "or r15, rax", - "and r15, 65535", - "mov rax, r12", - "mov rcx, r13", - "ror rcx, 48", - "or rax, rcx", - "mov rcx, r14", - "ror rcx, 32", - "or rax, rcx", - "mov rcx, r15", - "ror rcx, 16", - "or rax, rcx", - "mov QWORD PTR [rsi], rax", - "mov r12, QWORD PTR [rdx]", - "mov r13, QWORD PTR [rdx+8]", - "mov r14, QWORD PTR [rdx+16]", - "mov r15, QWORD PTR [rdx+24]", - "ret", - ) -} - -/// RC2 block decryption (RFC 2268 §4): decrypts `*data` in place under `*schedule`, the 64 little-endian 16-bit words written by `vg_rc2_expand_key`. -/// -/// Contract: `VG.Spec.Rc2.decryptBlockContract`. Constant time: only pointers may affect timing, not the key schedule or data, including the reverse-mashing indices. -/// -/// Baseline x86-64. Reverse mashing scans all 64 schedule words in a fixed order. -/// -/// # Safety -/// -/// * `schedule` must be valid for reads of 128 bytes. -/// * `data` must be valid for reads and writes of 8 bytes. -/// * `scratch` must be valid for reads and writes of 256 bytes. -/// * The contents of `scratch` on return are unspecified. -/// * `data` and `scratch` must not overlap each other or `schedule` (distinct Rust objects never do). -/// * None of `schedule`, `data` and `scratch` may overlap the return address on the stack, or wrap around the end of the address space (no Rust object does). -#[unsafe(naked)] -pub(crate) unsafe extern "sysv64" fn vg_rc2_decrypt_block(schedule: *const [u8; 128], data: *mut [u8; 8], scratch: *mut [u64; 32]) { - core::arch::naked_asm!( - "mov QWORD PTR [rdx], r12", - "mov QWORD PTR [rdx+8], r13", - "mov QWORD PTR [rdx+16], r14", - "mov QWORD PTR [rdx+24], r15", - "mov rax, QWORD PTR [rsi]", - "mov r12, rax", - "and r12, 65535", - "mov r13, rax", - "shr r13, 16", - "and r13, 65535", - "mov r14, rax", - "shr r14, 32", - "and r14, 65535", - "mov r15, rax", - "shr r15, 48", - "and r15, 65535", - "mov rax, r15", - "shr rax, 5", - "ror r15, 53", - "or r15, rax", - "and r15, 65535", - "mov r10, r14", - "and r10, r13", - "mov r11, r14", - "xor r11, -1", - "and r11, r12", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+126]", - "movzx r9d, BYTE PTR [rdi+127]", - "ror r9, 56", - "or r8, r9", - "sub r15, r8", - "sub r15, r10", - "and r15, 65535", - "mov rax, r14", - "shr rax, 3", - "ror r14, 51", - "or r14, rax", - "and r14, 65535", - "mov r10, r13", - "and r10, r12", - "mov r11, r13", - "xor r11, -1", - "and r11, r15", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+124]", - "movzx r9d, BYTE PTR [rdi+125]", - "ror r9, 56", - "or r8, r9", - "sub r14, r8", - "sub r14, r10", - "and r14, 65535", - "mov rax, r13", - "shr rax, 2", - "ror r13, 50", - "or r13, rax", - "and r13, 65535", - "mov r10, r12", - "and r10, r15", - "mov r11, r12", - "xor r11, -1", - "and r11, r14", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+122]", - "movzx r9d, BYTE PTR [rdi+123]", - "ror r9, 56", - "or r8, r9", - "sub r13, r8", - "sub r13, r10", - "and r13, 65535", - "mov rax, r12", - "shr rax, 1", - "ror r12, 49", - "or r12, rax", - "and r12, 65535", - "mov r10, r15", - "and r10, r14", - "mov r11, r15", - "xor r11, -1", - "and r11, r13", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+120]", - "movzx r9d, BYTE PTR [rdi+121]", - "ror r9, 56", - "or r8, r9", - "sub r12, r8", - "sub r12, r10", - "and r12, 65535", - "mov rax, r15", - "shr rax, 5", - "ror r15, 53", - "or r15, rax", - "and r15, 65535", - "mov r10, r14", - "and r10, r13", - "mov r11, r14", - "xor r11, -1", - "and r11, r12", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+118]", - "movzx r9d, BYTE PTR [rdi+119]", - "ror r9, 56", - "or r8, r9", - "sub r15, r8", - "sub r15, r10", - "and r15, 65535", - "mov rax, r14", - "shr rax, 3", - "ror r14, 51", - "or r14, rax", - "and r14, 65535", - "mov r10, r13", - "and r10, r12", - "mov r11, r13", - "xor r11, -1", - "and r11, r15", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+116]", - "movzx r9d, BYTE PTR [rdi+117]", - "ror r9, 56", - "or r8, r9", - "sub r14, r8", - "sub r14, r10", - "and r14, 65535", - "mov rax, r13", - "shr rax, 2", - "ror r13, 50", - "or r13, rax", - "and r13, 65535", - "mov r10, r12", - "and r10, r15", - "mov r11, r12", - "xor r11, -1", - "and r11, r14", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+114]", - "movzx r9d, BYTE PTR [rdi+115]", - "ror r9, 56", - "or r8, r9", - "sub r13, r8", - "sub r13, r10", - "and r13, 65535", - "mov rax, r12", - "shr rax, 1", - "ror r12, 49", - "or r12, rax", - "and r12, 65535", - "mov r10, r15", - "and r10, r14", - "mov r11, r15", - "xor r11, -1", - "and r11, r13", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+112]", - "movzx r9d, BYTE PTR [rdi+113]", - "ror r9, 56", - "or r8, r9", - "sub r12, r8", - "sub r12, r10", - "and r12, 65535", - "mov rax, r15", - "shr rax, 5", - "ror r15, 53", - "or r15, rax", - "and r15, 65535", - "mov r10, r14", - "and r10, r13", - "mov r11, r14", - "xor r11, -1", - "and r11, r12", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+110]", - "movzx r9d, BYTE PTR [rdi+111]", - "ror r9, 56", - "or r8, r9", - "sub r15, r8", - "sub r15, r10", - "and r15, 65535", - "mov rax, r14", - "shr rax, 3", - "ror r14, 51", - "or r14, rax", - "and r14, 65535", - "mov r10, r13", - "and r10, r12", - "mov r11, r13", - "xor r11, -1", - "and r11, r15", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+108]", - "movzx r9d, BYTE PTR [rdi+109]", - "ror r9, 56", - "or r8, r9", - "sub r14, r8", - "sub r14, r10", - "and r14, 65535", - "mov rax, r13", - "shr rax, 2", - "ror r13, 50", - "or r13, rax", - "and r13, 65535", - "mov r10, r12", - "and r10, r15", - "mov r11, r12", - "xor r11, -1", - "and r11, r14", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+106]", - "movzx r9d, BYTE PTR [rdi+107]", - "ror r9, 56", - "or r8, r9", - "sub r13, r8", - "sub r13, r10", - "and r13, 65535", - "mov rax, r12", - "shr rax, 1", - "ror r12, 49", - "or r12, rax", - "and r12, 65535", - "mov r10, r15", - "and r10, r14", - "mov r11, r15", - "xor r11, -1", - "and r11, r13", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+104]", - "movzx r9d, BYTE PTR [rdi+105]", - "ror r9, 56", - "or r8, r9", - "sub r12, r8", - "sub r12, r10", - "and r12, 65535", - "mov rax, r15", - "shr rax, 5", - "ror r15, 53", - "or r15, rax", - "and r15, 65535", - "mov r10, r14", - "and r10, r13", - "mov r11, r14", - "xor r11, -1", - "and r11, r12", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+102]", - "movzx r9d, BYTE PTR [rdi+103]", - "ror r9, 56", - "or r8, r9", - "sub r15, r8", - "sub r15, r10", - "and r15, 65535", - "mov rax, r14", - "shr rax, 3", - "ror r14, 51", - "or r14, rax", - "and r14, 65535", - "mov r10, r13", - "and r10, r12", - "mov r11, r13", - "xor r11, -1", - "and r11, r15", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+100]", - "movzx r9d, BYTE PTR [rdi+101]", - "ror r9, 56", - "or r8, r9", - "sub r14, r8", - "sub r14, r10", - "and r14, 65535", - "mov rax, r13", - "shr rax, 2", - "ror r13, 50", - "or r13, rax", - "and r13, 65535", - "mov r10, r12", - "and r10, r15", - "mov r11, r12", - "xor r11, -1", - "and r11, r14", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+98]", - "movzx r9d, BYTE PTR [rdi+99]", - "ror r9, 56", - "or r8, r9", - "sub r13, r8", - "sub r13, r10", - "and r13, 65535", - "mov rax, r12", - "shr rax, 1", - "ror r12, 49", - "or r12, rax", - "and r12, 65535", - "mov r10, r15", - "and r10, r14", - "mov r11, r15", - "xor r11, -1", - "and r11, r13", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+96]", - "movzx r9d, BYTE PTR [rdi+97]", - "ror r9, 56", - "or r8, r9", - "sub r12, r8", - "sub r12, r10", - "and r12, 65535", - "mov rax, r15", - "shr rax, 5", - "ror r15, 53", - "or r15, rax", - "and r15, 65535", - "mov r10, r14", - "and r10, r13", - "mov r11, r14", - "xor r11, -1", - "and r11, r12", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+94]", - "movzx r9d, BYTE PTR [rdi+95]", - "ror r9, 56", - "or r8, r9", - "sub r15, r8", - "sub r15, r10", - "and r15, 65535", - "mov rax, r14", - "shr rax, 3", - "ror r14, 51", - "or r14, rax", - "and r14, 65535", - "mov r10, r13", - "and r10, r12", - "mov r11, r13", - "xor r11, -1", - "and r11, r15", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+92]", - "movzx r9d, BYTE PTR [rdi+93]", - "ror r9, 56", - "or r8, r9", - "sub r14, r8", - "sub r14, r10", - "and r14, 65535", - "mov rax, r13", - "shr rax, 2", - "ror r13, 50", - "or r13, rax", - "and r13, 65535", - "mov r10, r12", - "and r10, r15", - "mov r11, r12", - "xor r11, -1", - "and r11, r14", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+90]", - "movzx r9d, BYTE PTR [rdi+91]", - "ror r9, 56", - "or r8, r9", - "sub r13, r8", - "sub r13, r10", - "and r13, 65535", - "mov rax, r12", - "shr rax, 1", - "ror r12, 49", - "or r12, rax", - "and r12, 65535", - "mov r10, r15", - "and r10, r14", - "mov r11, r15", - "xor r11, -1", - "and r11, r13", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+88]", - "movzx r9d, BYTE PTR [rdi+89]", - "ror r9, 56", - "or r8, r9", - "sub r12, r8", - "sub r12, r10", - "and r12, 65535", - "mov rax, r14", - "and rax, 63", - "mov rcx, 0", - "mov r10, rax", - "xor r10, 0", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi]", - "movzx r9d, BYTE PTR [rdi+1]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 1", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+2]", - "movzx r9d, BYTE PTR [rdi+3]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 2", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+4]", - "movzx r9d, BYTE PTR [rdi+5]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 3", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+6]", - "movzx r9d, BYTE PTR [rdi+7]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 4", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+8]", - "movzx r9d, BYTE PTR [rdi+9]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 5", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+10]", - "movzx r9d, BYTE PTR [rdi+11]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 6", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+12]", - "movzx r9d, BYTE PTR [rdi+13]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 7", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+14]", - "movzx r9d, BYTE PTR [rdi+15]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 8", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+16]", - "movzx r9d, BYTE PTR [rdi+17]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 9", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+18]", - "movzx r9d, BYTE PTR [rdi+19]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 10", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+20]", - "movzx r9d, BYTE PTR [rdi+21]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 11", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+22]", - "movzx r9d, BYTE PTR [rdi+23]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 12", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+24]", - "movzx r9d, BYTE PTR [rdi+25]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 13", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+26]", - "movzx r9d, BYTE PTR [rdi+27]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 14", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+28]", - "movzx r9d, BYTE PTR [rdi+29]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 15", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+30]", - "movzx r9d, BYTE PTR [rdi+31]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 16", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+32]", - "movzx r9d, BYTE PTR [rdi+33]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 17", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+34]", - "movzx r9d, BYTE PTR [rdi+35]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 18", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+36]", - "movzx r9d, BYTE PTR [rdi+37]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 19", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+38]", - "movzx r9d, BYTE PTR [rdi+39]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 20", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+40]", - "movzx r9d, BYTE PTR [rdi+41]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 21", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+42]", - "movzx r9d, BYTE PTR [rdi+43]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 22", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+44]", - "movzx r9d, BYTE PTR [rdi+45]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 23", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+46]", - "movzx r9d, BYTE PTR [rdi+47]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 24", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+48]", - "movzx r9d, BYTE PTR [rdi+49]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 25", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+50]", - "movzx r9d, BYTE PTR [rdi+51]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 26", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+52]", - "movzx r9d, BYTE PTR [rdi+53]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 27", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+54]", - "movzx r9d, BYTE PTR [rdi+55]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 28", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+56]", - "movzx r9d, BYTE PTR [rdi+57]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 29", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+58]", - "movzx r9d, BYTE PTR [rdi+59]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 30", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+60]", - "movzx r9d, BYTE PTR [rdi+61]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 31", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+62]", - "movzx r9d, BYTE PTR [rdi+63]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 32", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+64]", - "movzx r9d, BYTE PTR [rdi+65]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 33", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+66]", - "movzx r9d, BYTE PTR [rdi+67]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 34", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+68]", - "movzx r9d, BYTE PTR [rdi+69]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 35", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+70]", - "movzx r9d, BYTE PTR [rdi+71]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 36", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+72]", - "movzx r9d, BYTE PTR [rdi+73]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 37", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+74]", - "movzx r9d, BYTE PTR [rdi+75]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 38", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+76]", - "movzx r9d, BYTE PTR [rdi+77]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 39", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+78]", - "movzx r9d, BYTE PTR [rdi+79]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 40", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+80]", - "movzx r9d, BYTE PTR [rdi+81]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 41", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+82]", - "movzx r9d, BYTE PTR [rdi+83]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 42", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+84]", - "movzx r9d, BYTE PTR [rdi+85]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 43", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+86]", - "movzx r9d, BYTE PTR [rdi+87]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 44", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+88]", - "movzx r9d, BYTE PTR [rdi+89]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 45", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+90]", - "movzx r9d, BYTE PTR [rdi+91]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 46", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+92]", - "movzx r9d, BYTE PTR [rdi+93]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 47", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+94]", - "movzx r9d, BYTE PTR [rdi+95]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 48", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+96]", - "movzx r9d, BYTE PTR [rdi+97]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 49", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+98]", - "movzx r9d, BYTE PTR [rdi+99]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 50", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+100]", - "movzx r9d, BYTE PTR [rdi+101]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 51", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+102]", - "movzx r9d, BYTE PTR [rdi+103]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 52", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+104]", - "movzx r9d, BYTE PTR [rdi+105]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 53", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+106]", - "movzx r9d, BYTE PTR [rdi+107]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 54", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+108]", - "movzx r9d, BYTE PTR [rdi+109]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 55", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+110]", - "movzx r9d, BYTE PTR [rdi+111]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 56", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+112]", - "movzx r9d, BYTE PTR [rdi+113]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 57", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+114]", - "movzx r9d, BYTE PTR [rdi+115]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 58", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+116]", - "movzx r9d, BYTE PTR [rdi+117]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 59", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+118]", - "movzx r9d, BYTE PTR [rdi+119]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 60", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+120]", - "movzx r9d, BYTE PTR [rdi+121]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 61", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+122]", - "movzx r9d, BYTE PTR [rdi+123]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 62", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+124]", - "movzx r9d, BYTE PTR [rdi+125]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 63", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+126]", - "movzx r9d, BYTE PTR [rdi+127]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov rax, rcx", - "sub r15, rax", - "and r15, 65535", - "mov rax, r13", - "and rax, 63", - "mov rcx, 0", - "mov r10, rax", - "xor r10, 0", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi]", - "movzx r9d, BYTE PTR [rdi+1]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 1", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+2]", - "movzx r9d, BYTE PTR [rdi+3]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 2", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+4]", - "movzx r9d, BYTE PTR [rdi+5]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 3", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+6]", - "movzx r9d, BYTE PTR [rdi+7]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 4", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+8]", - "movzx r9d, BYTE PTR [rdi+9]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 5", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+10]", - "movzx r9d, BYTE PTR [rdi+11]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 6", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+12]", - "movzx r9d, BYTE PTR [rdi+13]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 7", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+14]", - "movzx r9d, BYTE PTR [rdi+15]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 8", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+16]", - "movzx r9d, BYTE PTR [rdi+17]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 9", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+18]", - "movzx r9d, BYTE PTR [rdi+19]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 10", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+20]", - "movzx r9d, BYTE PTR [rdi+21]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 11", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+22]", - "movzx r9d, BYTE PTR [rdi+23]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 12", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+24]", - "movzx r9d, BYTE PTR [rdi+25]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 13", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+26]", - "movzx r9d, BYTE PTR [rdi+27]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 14", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+28]", - "movzx r9d, BYTE PTR [rdi+29]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 15", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+30]", - "movzx r9d, BYTE PTR [rdi+31]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 16", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+32]", - "movzx r9d, BYTE PTR [rdi+33]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 17", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+34]", - "movzx r9d, BYTE PTR [rdi+35]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 18", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+36]", - "movzx r9d, BYTE PTR [rdi+37]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 19", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+38]", - "movzx r9d, BYTE PTR [rdi+39]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 20", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+40]", - "movzx r9d, BYTE PTR [rdi+41]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 21", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+42]", - "movzx r9d, BYTE PTR [rdi+43]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 22", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+44]", - "movzx r9d, BYTE PTR [rdi+45]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 23", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+46]", - "movzx r9d, BYTE PTR [rdi+47]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 24", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+48]", - "movzx r9d, BYTE PTR [rdi+49]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 25", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+50]", - "movzx r9d, BYTE PTR [rdi+51]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 26", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+52]", - "movzx r9d, BYTE PTR [rdi+53]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 27", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+54]", - "movzx r9d, BYTE PTR [rdi+55]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 28", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+56]", - "movzx r9d, BYTE PTR [rdi+57]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 29", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+58]", - "movzx r9d, BYTE PTR [rdi+59]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 30", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+60]", - "movzx r9d, BYTE PTR [rdi+61]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 31", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+62]", - "movzx r9d, BYTE PTR [rdi+63]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 32", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+64]", - "movzx r9d, BYTE PTR [rdi+65]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 33", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+66]", - "movzx r9d, BYTE PTR [rdi+67]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 34", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+68]", - "movzx r9d, BYTE PTR [rdi+69]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 35", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+70]", - "movzx r9d, BYTE PTR [rdi+71]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 36", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+72]", - "movzx r9d, BYTE PTR [rdi+73]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 37", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+74]", - "movzx r9d, BYTE PTR [rdi+75]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 38", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+76]", - "movzx r9d, BYTE PTR [rdi+77]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 39", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+78]", - "movzx r9d, BYTE PTR [rdi+79]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 40", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+80]", - "movzx r9d, BYTE PTR [rdi+81]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 41", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+82]", - "movzx r9d, BYTE PTR [rdi+83]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 42", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+84]", - "movzx r9d, BYTE PTR [rdi+85]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 43", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+86]", - "movzx r9d, BYTE PTR [rdi+87]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 44", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+88]", - "movzx r9d, BYTE PTR [rdi+89]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 45", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+90]", - "movzx r9d, BYTE PTR [rdi+91]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 46", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+92]", - "movzx r9d, BYTE PTR [rdi+93]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 47", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+94]", - "movzx r9d, BYTE PTR [rdi+95]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 48", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+96]", - "movzx r9d, BYTE PTR [rdi+97]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 49", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+98]", - "movzx r9d, BYTE PTR [rdi+99]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 50", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+100]", - "movzx r9d, BYTE PTR [rdi+101]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 51", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+102]", - "movzx r9d, BYTE PTR [rdi+103]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 52", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+104]", - "movzx r9d, BYTE PTR [rdi+105]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 53", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+106]", - "movzx r9d, BYTE PTR [rdi+107]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 54", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+108]", - "movzx r9d, BYTE PTR [rdi+109]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 55", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+110]", - "movzx r9d, BYTE PTR [rdi+111]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 56", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+112]", - "movzx r9d, BYTE PTR [rdi+113]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 57", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+114]", - "movzx r9d, BYTE PTR [rdi+115]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 58", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+116]", - "movzx r9d, BYTE PTR [rdi+117]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 59", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+118]", - "movzx r9d, BYTE PTR [rdi+119]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 60", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+120]", - "movzx r9d, BYTE PTR [rdi+121]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 61", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+122]", - "movzx r9d, BYTE PTR [rdi+123]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 62", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+124]", - "movzx r9d, BYTE PTR [rdi+125]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 63", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+126]", - "movzx r9d, BYTE PTR [rdi+127]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov rax, rcx", - "sub r14, rax", - "and r14, 65535", - "mov rax, r12", - "and rax, 63", - "mov rcx, 0", - "mov r10, rax", - "xor r10, 0", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi]", - "movzx r9d, BYTE PTR [rdi+1]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 1", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+2]", - "movzx r9d, BYTE PTR [rdi+3]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 2", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+4]", - "movzx r9d, BYTE PTR [rdi+5]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 3", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+6]", - "movzx r9d, BYTE PTR [rdi+7]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 4", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+8]", - "movzx r9d, BYTE PTR [rdi+9]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 5", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+10]", - "movzx r9d, BYTE PTR [rdi+11]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 6", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+12]", - "movzx r9d, BYTE PTR [rdi+13]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 7", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+14]", - "movzx r9d, BYTE PTR [rdi+15]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 8", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+16]", - "movzx r9d, BYTE PTR [rdi+17]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 9", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+18]", - "movzx r9d, BYTE PTR [rdi+19]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 10", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+20]", - "movzx r9d, BYTE PTR [rdi+21]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 11", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+22]", - "movzx r9d, BYTE PTR [rdi+23]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 12", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+24]", - "movzx r9d, BYTE PTR [rdi+25]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 13", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+26]", - "movzx r9d, BYTE PTR [rdi+27]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 14", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+28]", - "movzx r9d, BYTE PTR [rdi+29]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 15", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+30]", - "movzx r9d, BYTE PTR [rdi+31]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 16", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+32]", - "movzx r9d, BYTE PTR [rdi+33]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 17", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+34]", - "movzx r9d, BYTE PTR [rdi+35]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 18", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+36]", - "movzx r9d, BYTE PTR [rdi+37]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 19", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+38]", - "movzx r9d, BYTE PTR [rdi+39]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 20", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+40]", - "movzx r9d, BYTE PTR [rdi+41]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 21", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+42]", - "movzx r9d, BYTE PTR [rdi+43]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 22", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+44]", - "movzx r9d, BYTE PTR [rdi+45]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 23", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+46]", - "movzx r9d, BYTE PTR [rdi+47]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 24", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+48]", - "movzx r9d, BYTE PTR [rdi+49]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 25", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+50]", - "movzx r9d, BYTE PTR [rdi+51]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 26", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+52]", - "movzx r9d, BYTE PTR [rdi+53]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 27", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+54]", - "movzx r9d, BYTE PTR [rdi+55]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 28", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+56]", - "movzx r9d, BYTE PTR [rdi+57]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 29", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+58]", - "movzx r9d, BYTE PTR [rdi+59]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 30", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+60]", - "movzx r9d, BYTE PTR [rdi+61]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 31", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+62]", - "movzx r9d, BYTE PTR [rdi+63]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 32", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+64]", - "movzx r9d, BYTE PTR [rdi+65]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 33", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+66]", - "movzx r9d, BYTE PTR [rdi+67]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 34", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+68]", - "movzx r9d, BYTE PTR [rdi+69]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 35", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+70]", - "movzx r9d, BYTE PTR [rdi+71]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 36", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+72]", - "movzx r9d, BYTE PTR [rdi+73]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 37", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+74]", - "movzx r9d, BYTE PTR [rdi+75]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 38", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+76]", - "movzx r9d, BYTE PTR [rdi+77]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 39", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+78]", - "movzx r9d, BYTE PTR [rdi+79]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 40", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+80]", - "movzx r9d, BYTE PTR [rdi+81]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 41", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+82]", - "movzx r9d, BYTE PTR [rdi+83]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 42", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+84]", - "movzx r9d, BYTE PTR [rdi+85]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 43", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+86]", - "movzx r9d, BYTE PTR [rdi+87]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 44", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+88]", - "movzx r9d, BYTE PTR [rdi+89]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 45", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+90]", - "movzx r9d, BYTE PTR [rdi+91]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 46", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+92]", - "movzx r9d, BYTE PTR [rdi+93]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 47", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+94]", - "movzx r9d, BYTE PTR [rdi+95]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 48", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+96]", - "movzx r9d, BYTE PTR [rdi+97]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 49", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+98]", - "movzx r9d, BYTE PTR [rdi+99]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 50", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+100]", - "movzx r9d, BYTE PTR [rdi+101]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 51", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+102]", - "movzx r9d, BYTE PTR [rdi+103]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 52", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+104]", - "movzx r9d, BYTE PTR [rdi+105]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 53", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+106]", - "movzx r9d, BYTE PTR [rdi+107]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 54", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+108]", - "movzx r9d, BYTE PTR [rdi+109]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 55", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+110]", - "movzx r9d, BYTE PTR [rdi+111]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 56", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+112]", - "movzx r9d, BYTE PTR [rdi+113]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 57", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+114]", - "movzx r9d, BYTE PTR [rdi+115]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 58", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+116]", - "movzx r9d, BYTE PTR [rdi+117]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 59", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+118]", - "movzx r9d, BYTE PTR [rdi+119]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 60", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+120]", - "movzx r9d, BYTE PTR [rdi+121]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 61", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+122]", - "movzx r9d, BYTE PTR [rdi+123]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 62", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+124]", - "movzx r9d, BYTE PTR [rdi+125]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 63", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+126]", - "movzx r9d, BYTE PTR [rdi+127]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov rax, rcx", - "sub r13, rax", - "and r13, 65535", - "mov rax, r15", - "and rax, 63", - "mov rcx, 0", - "mov r10, rax", - "xor r10, 0", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi]", - "movzx r9d, BYTE PTR [rdi+1]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 1", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+2]", - "movzx r9d, BYTE PTR [rdi+3]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 2", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+4]", - "movzx r9d, BYTE PTR [rdi+5]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 3", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+6]", - "movzx r9d, BYTE PTR [rdi+7]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 4", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+8]", - "movzx r9d, BYTE PTR [rdi+9]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 5", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+10]", - "movzx r9d, BYTE PTR [rdi+11]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 6", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+12]", - "movzx r9d, BYTE PTR [rdi+13]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 7", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+14]", - "movzx r9d, BYTE PTR [rdi+15]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 8", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+16]", - "movzx r9d, BYTE PTR [rdi+17]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 9", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+18]", - "movzx r9d, BYTE PTR [rdi+19]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 10", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+20]", - "movzx r9d, BYTE PTR [rdi+21]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 11", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+22]", - "movzx r9d, BYTE PTR [rdi+23]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 12", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+24]", - "movzx r9d, BYTE PTR [rdi+25]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 13", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+26]", - "movzx r9d, BYTE PTR [rdi+27]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 14", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+28]", - "movzx r9d, BYTE PTR [rdi+29]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 15", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+30]", - "movzx r9d, BYTE PTR [rdi+31]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 16", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+32]", - "movzx r9d, BYTE PTR [rdi+33]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 17", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+34]", - "movzx r9d, BYTE PTR [rdi+35]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 18", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+36]", - "movzx r9d, BYTE PTR [rdi+37]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 19", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+38]", - "movzx r9d, BYTE PTR [rdi+39]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 20", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+40]", - "movzx r9d, BYTE PTR [rdi+41]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 21", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+42]", - "movzx r9d, BYTE PTR [rdi+43]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 22", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+44]", - "movzx r9d, BYTE PTR [rdi+45]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 23", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+46]", - "movzx r9d, BYTE PTR [rdi+47]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 24", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+48]", - "movzx r9d, BYTE PTR [rdi+49]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 25", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+50]", - "movzx r9d, BYTE PTR [rdi+51]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 26", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+52]", - "movzx r9d, BYTE PTR [rdi+53]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 27", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+54]", - "movzx r9d, BYTE PTR [rdi+55]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 28", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+56]", - "movzx r9d, BYTE PTR [rdi+57]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 29", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+58]", - "movzx r9d, BYTE PTR [rdi+59]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 30", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+60]", - "movzx r9d, BYTE PTR [rdi+61]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 31", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+62]", - "movzx r9d, BYTE PTR [rdi+63]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 32", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+64]", - "movzx r9d, BYTE PTR [rdi+65]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 33", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+66]", - "movzx r9d, BYTE PTR [rdi+67]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 34", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+68]", - "movzx r9d, BYTE PTR [rdi+69]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 35", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+70]", - "movzx r9d, BYTE PTR [rdi+71]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 36", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+72]", - "movzx r9d, BYTE PTR [rdi+73]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 37", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+74]", - "movzx r9d, BYTE PTR [rdi+75]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 38", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+76]", - "movzx r9d, BYTE PTR [rdi+77]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 39", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+78]", - "movzx r9d, BYTE PTR [rdi+79]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 40", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+80]", - "movzx r9d, BYTE PTR [rdi+81]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 41", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+82]", - "movzx r9d, BYTE PTR [rdi+83]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 42", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+84]", - "movzx r9d, BYTE PTR [rdi+85]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 43", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+86]", - "movzx r9d, BYTE PTR [rdi+87]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 44", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+88]", - "movzx r9d, BYTE PTR [rdi+89]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 45", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+90]", - "movzx r9d, BYTE PTR [rdi+91]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 46", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+92]", - "movzx r9d, BYTE PTR [rdi+93]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 47", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+94]", - "movzx r9d, BYTE PTR [rdi+95]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 48", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+96]", - "movzx r9d, BYTE PTR [rdi+97]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 49", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+98]", - "movzx r9d, BYTE PTR [rdi+99]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 50", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+100]", - "movzx r9d, BYTE PTR [rdi+101]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 51", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+102]", - "movzx r9d, BYTE PTR [rdi+103]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 52", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+104]", - "movzx r9d, BYTE PTR [rdi+105]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 53", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+106]", - "movzx r9d, BYTE PTR [rdi+107]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 54", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+108]", - "movzx r9d, BYTE PTR [rdi+109]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 55", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+110]", - "movzx r9d, BYTE PTR [rdi+111]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 56", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+112]", - "movzx r9d, BYTE PTR [rdi+113]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 57", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+114]", - "movzx r9d, BYTE PTR [rdi+115]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 58", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+116]", - "movzx r9d, BYTE PTR [rdi+117]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 59", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+118]", - "movzx r9d, BYTE PTR [rdi+119]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 60", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+120]", - "movzx r9d, BYTE PTR [rdi+121]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 61", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+122]", - "movzx r9d, BYTE PTR [rdi+123]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 62", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+124]", - "movzx r9d, BYTE PTR [rdi+125]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 63", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+126]", - "movzx r9d, BYTE PTR [rdi+127]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov rax, rcx", - "sub r12, rax", + "movq xmm0, rax", + "punpcklwd xmm0, xmm0", + "pshufd xmm0, xmm0, 0", + "pxor xmm1, xmm1", + "movabs r10, 844433520132096", + "movq xmm2, r10", + "movabs r10, 1970350607106052", + "movq xmm5, r10", + "punpcklqdq xmm2, xmm5", + "movabs r10, 281479271743489", + "movq xmm6, r10", + "movabs r10, 281479271743489", + "movq xmm5, r10", + "punpcklqdq xmm6, xmm5", + "movabs r10, 2251834173947912", + "movq xmm7, r10", + "movabs r10, 2251834173947912", + "movq xmm5, r10", + "punpcklqdq xmm7, xmm5", + "movdqu xmm4, XMMWORD PTR [rdi]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+16]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+32]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+48]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+64]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+80]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+96]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+112]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqa xmm3, xmm1", + "psrldq xmm3, 8", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 4", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 2", + "por xmm1, xmm3", + "movdqu XMMWORD PTR [rdx+64], xmm1", + "mov rax, QWORD PTR [rdx+64]", + "and rax, 65535", + "movdqu XMMWORD PTR [rdx+64], xmm8", + "add r12, rax", "and r12, 65535", - "mov rax, r15", - "shr rax, 5", - "ror r15, 53", - "or r15, rax", - "and r15, 65535", - "mov r10, r14", - "and r10, r13", - "mov r11, r14", - "xor r11, -1", - "and r11, r12", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+86]", - "movzx r9d, BYTE PTR [rdi+87]", - "ror r9, 56", - "or r8, r9", - "sub r15, r8", - "sub r15, r10", - "and r15, 65535", - "mov rax, r14", - "shr rax, 3", - "ror r14, 51", - "or r14, rax", - "and r14, 65535", - "mov r10, r13", - "and r10, r12", - "mov r11, r13", - "xor r11, -1", - "and r11, r15", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+84]", - "movzx r9d, BYTE PTR [rdi+85]", - "ror r9, 56", - "or r8, r9", - "sub r14, r8", - "sub r14, r10", - "and r14, 65535", - "mov rax, r13", - "shr rax, 2", - "ror r13, 50", - "or r13, rax", - "and r13, 65535", - "mov r10, r12", - "and r10, r15", - "mov r11, r12", - "xor r11, -1", - "and r11, r14", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+82]", - "movzx r9d, BYTE PTR [rdi+83]", - "ror r9, 56", - "or r8, r9", - "sub r13, r8", - "sub r13, r10", + "mov rax, r12", + "movdqu xmm8, XMMWORD PTR [rdx+64]", + "and rax, 63", + "movq xmm0, rax", + "punpcklwd xmm0, xmm0", + "pshufd xmm0, xmm0, 0", + "pxor xmm1, xmm1", + "movabs r10, 844433520132096", + "movq xmm2, r10", + "movabs r10, 1970350607106052", + "movq xmm5, r10", + "punpcklqdq xmm2, xmm5", + "movabs r10, 281479271743489", + "movq xmm6, r10", + "movabs r10, 281479271743489", + "movq xmm5, r10", + "punpcklqdq xmm6, xmm5", + "movabs r10, 2251834173947912", + "movq xmm7, r10", + "movabs r10, 2251834173947912", + "movq xmm5, r10", + "punpcklqdq xmm7, xmm5", + "movdqu xmm4, XMMWORD PTR [rdi]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+16]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+32]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+48]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+64]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+80]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+96]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+112]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqa xmm3, xmm1", + "psrldq xmm3, 8", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 4", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 2", + "por xmm1, xmm3", + "movdqu XMMWORD PTR [rdx+64], xmm1", + "mov rax, QWORD PTR [rdx+64]", + "and rax, 65535", + "movdqu XMMWORD PTR [rdx+64], xmm8", + "add r13, rax", "and r13, 65535", - "mov rax, r12", - "shr rax, 1", - "ror r12, 49", - "or r12, rax", - "and r12, 65535", - "mov r10, r15", - "and r10, r14", - "mov r11, r15", - "xor r11, -1", - "and r11, r13", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+80]", - "movzx r9d, BYTE PTR [rdi+81]", - "ror r9, 56", - "or r8, r9", - "sub r12, r8", - "sub r12, r10", - "and r12, 65535", - "mov rax, r15", - "shr rax, 5", - "ror r15, 53", - "or r15, rax", - "and r15, 65535", - "mov r10, r14", - "and r10, r13", - "mov r11, r14", - "xor r11, -1", - "and r11, r12", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+78]", - "movzx r9d, BYTE PTR [rdi+79]", - "ror r9, 56", - "or r8, r9", - "sub r15, r8", - "sub r15, r10", - "and r15, 65535", - "mov rax, r14", - "shr rax, 3", - "ror r14, 51", - "or r14, rax", - "and r14, 65535", - "mov r10, r13", - "and r10, r12", - "mov r11, r13", - "xor r11, -1", - "and r11, r15", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+76]", - "movzx r9d, BYTE PTR [rdi+77]", - "ror r9, 56", - "or r8, r9", - "sub r14, r8", - "sub r14, r10", - "and r14, 65535", "mov rax, r13", - "shr rax, 2", - "ror r13, 50", - "or r13, rax", - "and r13, 65535", - "mov r10, r12", - "and r10, r15", - "mov r11, r12", - "xor r11, -1", - "and r11, r14", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+74]", - "movzx r9d, BYTE PTR [rdi+75]", - "ror r9, 56", - "or r8, r9", - "sub r13, r8", - "sub r13, r10", - "and r13, 65535", - "mov rax, r12", - "shr rax, 1", - "ror r12, 49", - "or r12, rax", - "and r12, 65535", - "mov r10, r15", - "and r10, r14", - "mov r11, r15", - "xor r11, -1", - "and r11, r13", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+72]", - "movzx r9d, BYTE PTR [rdi+73]", - "ror r9, 56", - "or r8, r9", - "sub r12, r8", - "sub r12, r10", - "and r12, 65535", - "mov rax, r15", - "shr rax, 5", - "ror r15, 53", - "or r15, rax", - "and r15, 65535", - "mov r10, r14", - "and r10, r13", - "mov r11, r14", - "xor r11, -1", - "and r11, r12", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+70]", - "movzx r9d, BYTE PTR [rdi+71]", - "ror r9, 56", - "or r8, r9", - "sub r15, r8", - "sub r15, r10", - "and r15, 65535", - "mov rax, r14", - "shr rax, 3", - "ror r14, 51", - "or r14, rax", - "and r14, 65535", - "mov r10, r13", - "and r10, r12", - "mov r11, r13", - "xor r11, -1", - "and r11, r15", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+68]", - "movzx r9d, BYTE PTR [rdi+69]", - "ror r9, 56", - "or r8, r9", - "sub r14, r8", - "sub r14, r10", + "movdqu xmm8, XMMWORD PTR [rdx+64]", + "and rax, 63", + "movq xmm0, rax", + "punpcklwd xmm0, xmm0", + "pshufd xmm0, xmm0, 0", + "pxor xmm1, xmm1", + "movabs r10, 844433520132096", + "movq xmm2, r10", + "movabs r10, 1970350607106052", + "movq xmm5, r10", + "punpcklqdq xmm2, xmm5", + "movabs r10, 281479271743489", + "movq xmm6, r10", + "movabs r10, 281479271743489", + "movq xmm5, r10", + "punpcklqdq xmm6, xmm5", + "movabs r10, 2251834173947912", + "movq xmm7, r10", + "movabs r10, 2251834173947912", + "movq xmm5, r10", + "punpcklqdq xmm7, xmm5", + "movdqu xmm4, XMMWORD PTR [rdi]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+16]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+32]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+48]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+64]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+80]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+96]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+112]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqa xmm3, xmm1", + "psrldq xmm3, 8", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 4", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 2", + "por xmm1, xmm3", + "movdqu XMMWORD PTR [rdx+64], xmm1", + "mov rax, QWORD PTR [rdx+64]", + "and rax, 65535", + "movdqu XMMWORD PTR [rdx+64], xmm8", + "add r14, rax", "and r14, 65535", - "mov rax, r13", - "shr rax, 2", - "ror r13, 50", - "or r13, rax", - "and r13, 65535", - "mov r10, r12", - "and r10, r15", - "mov r11, r12", - "xor r11, -1", - "and r11, r14", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+66]", - "movzx r9d, BYTE PTR [rdi+67]", - "ror r9, 56", - "or r8, r9", - "sub r13, r8", - "sub r13, r10", - "and r13, 65535", - "mov rax, r12", - "shr rax, 1", - "ror r12, 49", - "or r12, rax", - "and r12, 65535", - "mov r10, r15", - "and r10, r14", - "mov r11, r15", - "xor r11, -1", - "and r11, r13", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+64]", - "movzx r9d, BYTE PTR [rdi+65]", - "ror r9, 56", - "or r8, r9", - "sub r12, r8", - "sub r12, r10", - "and r12, 65535", - "mov rax, r15", - "shr rax, 5", - "ror r15, 53", - "or r15, rax", - "and r15, 65535", - "mov r10, r14", - "and r10, r13", - "mov r11, r14", - "xor r11, -1", - "and r11, r12", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+62]", - "movzx r9d, BYTE PTR [rdi+63]", - "ror r9, 56", - "or r8, r9", - "sub r15, r8", - "sub r15, r10", - "and r15, 65535", "mov rax, r14", - "shr rax, 3", - "ror r14, 51", - "or r14, rax", - "and r14, 65535", - "mov r10, r13", - "and r10, r12", - "mov r11, r13", - "xor r11, -1", - "and r11, r15", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+60]", - "movzx r9d, BYTE PTR [rdi+61]", - "ror r9, 56", - "or r8, r9", - "sub r14, r8", - "sub r14, r10", - "and r14, 65535", - "mov rax, r13", - "shr rax, 2", - "ror r13, 50", - "or r13, rax", - "and r13, 65535", - "mov r10, r12", - "and r10, r15", - "mov r11, r12", - "xor r11, -1", - "and r11, r14", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+58]", - "movzx r9d, BYTE PTR [rdi+59]", - "ror r9, 56", - "or r8, r9", - "sub r13, r8", - "sub r13, r10", - "and r13, 65535", - "mov rax, r12", - "shr rax, 1", - "ror r12, 49", - "or r12, rax", - "and r12, 65535", - "mov r10, r15", - "and r10, r14", - "mov r11, r15", - "xor r11, -1", - "and r11, r13", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+56]", - "movzx r9d, BYTE PTR [rdi+57]", - "ror r9, 56", - "or r8, r9", - "sub r12, r8", - "sub r12, r10", - "and r12, 65535", - "mov rax, r15", - "shr rax, 5", - "ror r15, 53", - "or r15, rax", - "and r15, 65535", - "mov r10, r14", - "and r10, r13", - "mov r11, r14", - "xor r11, -1", - "and r11, r12", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+54]", - "movzx r9d, BYTE PTR [rdi+55]", - "ror r9, 56", - "or r8, r9", - "sub r15, r8", - "sub r15, r10", + "movdqu xmm8, XMMWORD PTR [rdx+64]", + "and rax, 63", + "movq xmm0, rax", + "punpcklwd xmm0, xmm0", + "pshufd xmm0, xmm0, 0", + "pxor xmm1, xmm1", + "movabs r10, 844433520132096", + "movq xmm2, r10", + "movabs r10, 1970350607106052", + "movq xmm5, r10", + "punpcklqdq xmm2, xmm5", + "movabs r10, 281479271743489", + "movq xmm6, r10", + "movabs r10, 281479271743489", + "movq xmm5, r10", + "punpcklqdq xmm6, xmm5", + "movabs r10, 2251834173947912", + "movq xmm7, r10", + "movabs r10, 2251834173947912", + "movq xmm5, r10", + "punpcklqdq xmm7, xmm5", + "movdqu xmm4, XMMWORD PTR [rdi]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+16]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+32]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+48]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+64]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+80]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+96]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+112]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqa xmm3, xmm1", + "psrldq xmm3, 8", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 4", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 2", + "por xmm1, xmm3", + "movdqu XMMWORD PTR [rdx+64], xmm1", + "mov rax, QWORD PTR [rdx+64]", + "and rax, 65535", + "movdqu XMMWORD PTR [rdx+64], xmm8", + "add r15, rax", "and r15, 65535", - "mov rax, r14", - "shr rax, 3", - "ror r14, 51", - "or r14, rax", - "and r14, 65535", - "mov r10, r13", - "and r10, r12", - "mov r11, r13", - "xor r11, -1", - "and r11, r15", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+52]", - "movzx r9d, BYTE PTR [rdi+53]", - "ror r9, 56", - "or r8, r9", - "sub r14, r8", - "sub r14, r10", - "and r14, 65535", - "mov rax, r13", - "shr rax, 2", - "ror r13, 50", - "or r13, rax", - "and r13, 65535", - "mov r10, r12", - "and r10, r15", - "mov r11, r12", - "xor r11, -1", - "and r11, r14", - "add r10, r11", - "movzx r8d, BYTE PTR [rdi+50]", - "movzx r9d, BYTE PTR [rdi+51]", - "ror r9, 56", - "or r8, r9", - "sub r13, r8", - "sub r13, r10", - "and r13, 65535", - "mov rax, r12", - "shr rax, 1", - "ror r12, 49", - "or r12, rax", - "and r12, 65535", "mov r10, r15", "and r10, r14", "mov r11, r15", "xor r11, -1", "and r11, r13", "add r10, r11", - "movzx r8d, BYTE PTR [rdi+48]", - "movzx r9d, BYTE PTR [rdi+49]", + "movzx r8d, BYTE PTR [rdi+40]", + "movzx r9d, BYTE PTR [rdi+41]", "ror r9, 56", "or r8, r9", - "sub r12, r8", - "sub r12, r10", + "add r12, r8", + "add r12, r10", "and r12, 65535", - "mov rax, r15", - "shr rax, 5", - "ror r15, 53", - "or r15, rax", - "and r15, 65535", - "mov r10, r14", - "and r10, r13", - "mov r11, r14", + "mov rax, r12", + "shr rax, 15", + "ror r12, 63", + "or r12, rax", + "and r12, 65535", + "mov r10, r12", + "and r10, r15", + "mov r11, r12", "xor r11, -1", - "and r11, r12", + "and r11, r14", "add r10, r11", - "movzx r8d, BYTE PTR [rdi+46]", - "movzx r9d, BYTE PTR [rdi+47]", + "movzx r8d, BYTE PTR [rdi+42]", + "movzx r9d, BYTE PTR [rdi+43]", "ror r9, 56", "or r8, r9", - "sub r15, r8", - "sub r15, r10", - "and r15, 65535", - "mov rax, r14", - "shr rax, 3", - "ror r14, 51", - "or r14, rax", - "and r14, 65535", + "add r13, r8", + "add r13, r10", + "and r13, 65535", + "mov rax, r13", + "shr rax, 14", + "ror r13, 62", + "or r13, rax", + "and r13, 65535", "mov r10, r13", "and r10, r12", "mov r11, r13", @@ -11221,2627 +2322,2806 @@ pub(crate) unsafe extern "sysv64" fn vg_rc2_decrypt_block(schedule: *const [u8; "movzx r9d, BYTE PTR [rdi+45]", "ror r9, 56", "or r8, r9", - "sub r14, r8", - "sub r14, r10", + "add r14, r8", + "add r14, r10", "and r14, 65535", - "mov rax, r13", - "shr rax, 2", - "ror r13, 50", - "or r13, rax", - "and r13, 65535", - "mov r10, r12", - "and r10, r15", - "mov r11, r12", + "mov rax, r14", + "shr rax, 13", + "ror r14, 61", + "or r14, rax", + "and r14, 65535", + "mov r10, r14", + "and r10, r13", + "mov r11, r14", "xor r11, -1", - "and r11, r14", + "and r11, r12", "add r10, r11", - "movzx r8d, BYTE PTR [rdi+42]", - "movzx r9d, BYTE PTR [rdi+43]", + "movzx r8d, BYTE PTR [rdi+46]", + "movzx r9d, BYTE PTR [rdi+47]", "ror r9, 56", "or r8, r9", - "sub r13, r8", - "sub r13, r10", - "and r13, 65535", - "mov rax, r12", - "shr rax, 1", - "ror r12, 49", - "or r12, rax", - "and r12, 65535", + "add r15, r8", + "add r15, r10", + "and r15, 65535", + "mov rax, r15", + "shr rax, 11", + "ror r15, 59", + "or r15, rax", + "and r15, 65535", "mov r10, r15", "and r10, r14", "mov r11, r15", "xor r11, -1", "and r11, r13", "add r10, r11", - "movzx r8d, BYTE PTR [rdi+40]", - "movzx r9d, BYTE PTR [rdi+41]", - "ror r9, 56", - "or r8, r9", - "sub r12, r8", - "sub r12, r10", - "and r12, 65535", - "mov rax, r14", - "and rax, 63", - "mov rcx, 0", - "mov r10, rax", - "xor r10, 0", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi]", - "movzx r9d, BYTE PTR [rdi+1]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 1", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+2]", - "movzx r9d, BYTE PTR [rdi+3]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 2", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+4]", - "movzx r9d, BYTE PTR [rdi+5]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 3", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+6]", - "movzx r9d, BYTE PTR [rdi+7]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 4", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+8]", - "movzx r9d, BYTE PTR [rdi+9]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 5", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+10]", - "movzx r9d, BYTE PTR [rdi+11]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 6", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+12]", - "movzx r9d, BYTE PTR [rdi+13]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 7", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+14]", - "movzx r9d, BYTE PTR [rdi+15]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 8", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+16]", - "movzx r9d, BYTE PTR [rdi+17]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 9", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+18]", - "movzx r9d, BYTE PTR [rdi+19]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 10", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+20]", - "movzx r9d, BYTE PTR [rdi+21]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 11", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+22]", - "movzx r9d, BYTE PTR [rdi+23]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 12", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+24]", - "movzx r9d, BYTE PTR [rdi+25]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 13", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+26]", - "movzx r9d, BYTE PTR [rdi+27]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 14", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+28]", - "movzx r9d, BYTE PTR [rdi+29]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 15", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+30]", - "movzx r9d, BYTE PTR [rdi+31]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 16", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+32]", - "movzx r9d, BYTE PTR [rdi+33]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 17", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+34]", - "movzx r9d, BYTE PTR [rdi+35]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 18", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+36]", - "movzx r9d, BYTE PTR [rdi+37]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 19", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+38]", - "movzx r9d, BYTE PTR [rdi+39]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 20", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+40]", - "movzx r9d, BYTE PTR [rdi+41]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 21", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+42]", - "movzx r9d, BYTE PTR [rdi+43]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 22", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+44]", - "movzx r9d, BYTE PTR [rdi+45]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 23", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+46]", - "movzx r9d, BYTE PTR [rdi+47]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 24", - "sub r10, 1", - "sbb r10, r10", "movzx r8d, BYTE PTR [rdi+48]", "movzx r9d, BYTE PTR [rdi+49]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 25", - "sub r10, 1", - "sbb r10, r10", + "add r12, r8", + "add r12, r10", + "and r12, 65535", + "mov rax, r12", + "shr rax, 15", + "ror r12, 63", + "or r12, rax", + "and r12, 65535", + "mov r10, r12", + "and r10, r15", + "mov r11, r12", + "xor r11, -1", + "and r11, r14", + "add r10, r11", "movzx r8d, BYTE PTR [rdi+50]", "movzx r9d, BYTE PTR [rdi+51]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 26", - "sub r10, 1", - "sbb r10, r10", + "add r13, r8", + "add r13, r10", + "and r13, 65535", + "mov rax, r13", + "shr rax, 14", + "ror r13, 62", + "or r13, rax", + "and r13, 65535", + "mov r10, r13", + "and r10, r12", + "mov r11, r13", + "xor r11, -1", + "and r11, r15", + "add r10, r11", "movzx r8d, BYTE PTR [rdi+52]", "movzx r9d, BYTE PTR [rdi+53]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 27", - "sub r10, 1", - "sbb r10, r10", + "add r14, r8", + "add r14, r10", + "and r14, 65535", + "mov rax, r14", + "shr rax, 13", + "ror r14, 61", + "or r14, rax", + "and r14, 65535", + "mov r10, r14", + "and r10, r13", + "mov r11, r14", + "xor r11, -1", + "and r11, r12", + "add r10, r11", "movzx r8d, BYTE PTR [rdi+54]", "movzx r9d, BYTE PTR [rdi+55]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 28", - "sub r10, 1", - "sbb r10, r10", + "add r15, r8", + "add r15, r10", + "and r15, 65535", + "mov rax, r15", + "shr rax, 11", + "ror r15, 59", + "or r15, rax", + "and r15, 65535", + "mov r10, r15", + "and r10, r14", + "mov r11, r15", + "xor r11, -1", + "and r11, r13", + "add r10, r11", "movzx r8d, BYTE PTR [rdi+56]", "movzx r9d, BYTE PTR [rdi+57]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 29", - "sub r10, 1", - "sbb r10, r10", + "add r12, r8", + "add r12, r10", + "and r12, 65535", + "mov rax, r12", + "shr rax, 15", + "ror r12, 63", + "or r12, rax", + "and r12, 65535", + "mov r10, r12", + "and r10, r15", + "mov r11, r12", + "xor r11, -1", + "and r11, r14", + "add r10, r11", "movzx r8d, BYTE PTR [rdi+58]", "movzx r9d, BYTE PTR [rdi+59]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 30", - "sub r10, 1", - "sbb r10, r10", + "add r13, r8", + "add r13, r10", + "and r13, 65535", + "mov rax, r13", + "shr rax, 14", + "ror r13, 62", + "or r13, rax", + "and r13, 65535", + "mov r10, r13", + "and r10, r12", + "mov r11, r13", + "xor r11, -1", + "and r11, r15", + "add r10, r11", "movzx r8d, BYTE PTR [rdi+60]", "movzx r9d, BYTE PTR [rdi+61]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 31", - "sub r10, 1", - "sbb r10, r10", + "add r14, r8", + "add r14, r10", + "and r14, 65535", + "mov rax, r14", + "shr rax, 13", + "ror r14, 61", + "or r14, rax", + "and r14, 65535", + "mov r10, r14", + "and r10, r13", + "mov r11, r14", + "xor r11, -1", + "and r11, r12", + "add r10, r11", "movzx r8d, BYTE PTR [rdi+62]", "movzx r9d, BYTE PTR [rdi+63]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 32", - "sub r10, 1", - "sbb r10, r10", + "add r15, r8", + "add r15, r10", + "and r15, 65535", + "mov rax, r15", + "shr rax, 11", + "ror r15, 59", + "or r15, rax", + "and r15, 65535", + "mov r10, r15", + "and r10, r14", + "mov r11, r15", + "xor r11, -1", + "and r11, r13", + "add r10, r11", "movzx r8d, BYTE PTR [rdi+64]", "movzx r9d, BYTE PTR [rdi+65]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 33", - "sub r10, 1", - "sbb r10, r10", + "add r12, r8", + "add r12, r10", + "and r12, 65535", + "mov rax, r12", + "shr rax, 15", + "ror r12, 63", + "or r12, rax", + "and r12, 65535", + "mov r10, r12", + "and r10, r15", + "mov r11, r12", + "xor r11, -1", + "and r11, r14", + "add r10, r11", "movzx r8d, BYTE PTR [rdi+66]", "movzx r9d, BYTE PTR [rdi+67]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 34", - "sub r10, 1", - "sbb r10, r10", + "add r13, r8", + "add r13, r10", + "and r13, 65535", + "mov rax, r13", + "shr rax, 14", + "ror r13, 62", + "or r13, rax", + "and r13, 65535", + "mov r10, r13", + "and r10, r12", + "mov r11, r13", + "xor r11, -1", + "and r11, r15", + "add r10, r11", "movzx r8d, BYTE PTR [rdi+68]", "movzx r9d, BYTE PTR [rdi+69]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 35", - "sub r10, 1", - "sbb r10, r10", + "add r14, r8", + "add r14, r10", + "and r14, 65535", + "mov rax, r14", + "shr rax, 13", + "ror r14, 61", + "or r14, rax", + "and r14, 65535", + "mov r10, r14", + "and r10, r13", + "mov r11, r14", + "xor r11, -1", + "and r11, r12", + "add r10, r11", "movzx r8d, BYTE PTR [rdi+70]", "movzx r9d, BYTE PTR [rdi+71]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 36", - "sub r10, 1", - "sbb r10, r10", + "add r15, r8", + "add r15, r10", + "and r15, 65535", + "mov rax, r15", + "shr rax, 11", + "ror r15, 59", + "or r15, rax", + "and r15, 65535", + "mov r10, r15", + "and r10, r14", + "mov r11, r15", + "xor r11, -1", + "and r11, r13", + "add r10, r11", "movzx r8d, BYTE PTR [rdi+72]", "movzx r9d, BYTE PTR [rdi+73]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 37", - "sub r10, 1", - "sbb r10, r10", + "add r12, r8", + "add r12, r10", + "and r12, 65535", + "mov rax, r12", + "shr rax, 15", + "ror r12, 63", + "or r12, rax", + "and r12, 65535", + "mov r10, r12", + "and r10, r15", + "mov r11, r12", + "xor r11, -1", + "and r11, r14", + "add r10, r11", "movzx r8d, BYTE PTR [rdi+74]", "movzx r9d, BYTE PTR [rdi+75]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 38", - "sub r10, 1", - "sbb r10, r10", + "add r13, r8", + "add r13, r10", + "and r13, 65535", + "mov rax, r13", + "shr rax, 14", + "ror r13, 62", + "or r13, rax", + "and r13, 65535", + "mov r10, r13", + "and r10, r12", + "mov r11, r13", + "xor r11, -1", + "and r11, r15", + "add r10, r11", "movzx r8d, BYTE PTR [rdi+76]", "movzx r9d, BYTE PTR [rdi+77]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 39", - "sub r10, 1", - "sbb r10, r10", + "add r14, r8", + "add r14, r10", + "and r14, 65535", + "mov rax, r14", + "shr rax, 13", + "ror r14, 61", + "or r14, rax", + "and r14, 65535", + "mov r10, r14", + "and r10, r13", + "mov r11, r14", + "xor r11, -1", + "and r11, r12", + "add r10, r11", "movzx r8d, BYTE PTR [rdi+78]", "movzx r9d, BYTE PTR [rdi+79]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 40", - "sub r10, 1", - "sbb r10, r10", + "add r15, r8", + "add r15, r10", + "and r15, 65535", + "mov rax, r15", + "shr rax, 11", + "ror r15, 59", + "or r15, rax", + "and r15, 65535", + "mov r10, r15", + "and r10, r14", + "mov r11, r15", + "xor r11, -1", + "and r11, r13", + "add r10, r11", "movzx r8d, BYTE PTR [rdi+80]", "movzx r9d, BYTE PTR [rdi+81]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 41", - "sub r10, 1", - "sbb r10, r10", + "add r12, r8", + "add r12, r10", + "and r12, 65535", + "mov rax, r12", + "shr rax, 15", + "ror r12, 63", + "or r12, rax", + "and r12, 65535", + "mov r10, r12", + "and r10, r15", + "mov r11, r12", + "xor r11, -1", + "and r11, r14", + "add r10, r11", "movzx r8d, BYTE PTR [rdi+82]", "movzx r9d, BYTE PTR [rdi+83]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 42", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+84]", - "movzx r9d, BYTE PTR [rdi+85]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 43", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+86]", - "movzx r9d, BYTE PTR [rdi+87]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 44", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+88]", - "movzx r9d, BYTE PTR [rdi+89]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 45", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+90]", - "movzx r9d, BYTE PTR [rdi+91]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 46", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+92]", - "movzx r9d, BYTE PTR [rdi+93]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 47", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+94]", - "movzx r9d, BYTE PTR [rdi+95]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 48", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+96]", - "movzx r9d, BYTE PTR [rdi+97]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 49", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+98]", - "movzx r9d, BYTE PTR [rdi+99]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 50", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+100]", - "movzx r9d, BYTE PTR [rdi+101]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 51", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+102]", - "movzx r9d, BYTE PTR [rdi+103]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 52", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+104]", - "movzx r9d, BYTE PTR [rdi+105]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 53", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+106]", - "movzx r9d, BYTE PTR [rdi+107]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 54", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+108]", - "movzx r9d, BYTE PTR [rdi+109]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 55", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+110]", - "movzx r9d, BYTE PTR [rdi+111]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 56", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+112]", - "movzx r9d, BYTE PTR [rdi+113]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 57", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+114]", - "movzx r9d, BYTE PTR [rdi+115]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 58", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+116]", - "movzx r9d, BYTE PTR [rdi+117]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 59", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+118]", - "movzx r9d, BYTE PTR [rdi+119]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 60", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+120]", - "movzx r9d, BYTE PTR [rdi+121]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 61", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+122]", - "movzx r9d, BYTE PTR [rdi+123]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 62", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+124]", - "movzx r9d, BYTE PTR [rdi+125]", + "add r13, r8", + "add r13, r10", + "and r13, 65535", + "mov rax, r13", + "shr rax, 14", + "ror r13, 62", + "or r13, rax", + "and r13, 65535", + "mov r10, r13", + "and r10, r12", + "mov r11, r13", + "xor r11, -1", + "and r11, r15", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+84]", + "movzx r9d, BYTE PTR [rdi+85]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 63", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+126]", - "movzx r9d, BYTE PTR [rdi+127]", + "add r14, r8", + "add r14, r10", + "and r14, 65535", + "mov rax, r14", + "shr rax, 13", + "ror r14, 61", + "or r14, rax", + "and r14, 65535", + "mov r10, r14", + "and r10, r13", + "mov r11, r14", + "xor r11, -1", + "and r11, r12", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+86]", + "movzx r9d, BYTE PTR [rdi+87]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov rax, rcx", - "sub r15, rax", + "add r15, r8", + "add r15, r10", + "and r15, 65535", + "mov rax, r15", + "shr rax, 11", + "ror r15, 59", + "or r15, rax", "and r15, 65535", + "mov rax, r15", + "movdqu xmm8, XMMWORD PTR [rdx+64]", + "and rax, 63", + "movq xmm0, rax", + "punpcklwd xmm0, xmm0", + "pshufd xmm0, xmm0, 0", + "pxor xmm1, xmm1", + "movabs r10, 844433520132096", + "movq xmm2, r10", + "movabs r10, 1970350607106052", + "movq xmm5, r10", + "punpcklqdq xmm2, xmm5", + "movabs r10, 281479271743489", + "movq xmm6, r10", + "movabs r10, 281479271743489", + "movq xmm5, r10", + "punpcklqdq xmm6, xmm5", + "movabs r10, 2251834173947912", + "movq xmm7, r10", + "movabs r10, 2251834173947912", + "movq xmm5, r10", + "punpcklqdq xmm7, xmm5", + "movdqu xmm4, XMMWORD PTR [rdi]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+16]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+32]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+48]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+64]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+80]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+96]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+112]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqa xmm3, xmm1", + "psrldq xmm3, 8", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 4", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 2", + "por xmm1, xmm3", + "movdqu XMMWORD PTR [rdx+64], xmm1", + "mov rax, QWORD PTR [rdx+64]", + "and rax, 65535", + "movdqu XMMWORD PTR [rdx+64], xmm8", + "add r12, rax", + "and r12, 65535", + "mov rax, r12", + "movdqu xmm8, XMMWORD PTR [rdx+64]", + "and rax, 63", + "movq xmm0, rax", + "punpcklwd xmm0, xmm0", + "pshufd xmm0, xmm0, 0", + "pxor xmm1, xmm1", + "movabs r10, 844433520132096", + "movq xmm2, r10", + "movabs r10, 1970350607106052", + "movq xmm5, r10", + "punpcklqdq xmm2, xmm5", + "movabs r10, 281479271743489", + "movq xmm6, r10", + "movabs r10, 281479271743489", + "movq xmm5, r10", + "punpcklqdq xmm6, xmm5", + "movabs r10, 2251834173947912", + "movq xmm7, r10", + "movabs r10, 2251834173947912", + "movq xmm5, r10", + "punpcklqdq xmm7, xmm5", + "movdqu xmm4, XMMWORD PTR [rdi]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+16]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+32]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+48]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+64]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+80]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+96]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+112]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqa xmm3, xmm1", + "psrldq xmm3, 8", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 4", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 2", + "por xmm1, xmm3", + "movdqu XMMWORD PTR [rdx+64], xmm1", + "mov rax, QWORD PTR [rdx+64]", + "and rax, 65535", + "movdqu XMMWORD PTR [rdx+64], xmm8", + "add r13, rax", + "and r13, 65535", "mov rax, r13", + "movdqu xmm8, XMMWORD PTR [rdx+64]", + "and rax, 63", + "movq xmm0, rax", + "punpcklwd xmm0, xmm0", + "pshufd xmm0, xmm0, 0", + "pxor xmm1, xmm1", + "movabs r10, 844433520132096", + "movq xmm2, r10", + "movabs r10, 1970350607106052", + "movq xmm5, r10", + "punpcklqdq xmm2, xmm5", + "movabs r10, 281479271743489", + "movq xmm6, r10", + "movabs r10, 281479271743489", + "movq xmm5, r10", + "punpcklqdq xmm6, xmm5", + "movabs r10, 2251834173947912", + "movq xmm7, r10", + "movabs r10, 2251834173947912", + "movq xmm5, r10", + "punpcklqdq xmm7, xmm5", + "movdqu xmm4, XMMWORD PTR [rdi]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+16]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+32]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+48]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+64]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+80]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+96]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+112]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqa xmm3, xmm1", + "psrldq xmm3, 8", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 4", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 2", + "por xmm1, xmm3", + "movdqu XMMWORD PTR [rdx+64], xmm1", + "mov rax, QWORD PTR [rdx+64]", + "and rax, 65535", + "movdqu XMMWORD PTR [rdx+64], xmm8", + "add r14, rax", + "and r14, 65535", + "mov rax, r14", + "movdqu xmm8, XMMWORD PTR [rdx+64]", "and rax, 63", - "mov rcx, 0", - "mov r10, rax", - "xor r10, 0", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi]", - "movzx r9d, BYTE PTR [rdi+1]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 1", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+2]", - "movzx r9d, BYTE PTR [rdi+3]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 2", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+4]", - "movzx r9d, BYTE PTR [rdi+5]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 3", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+6]", - "movzx r9d, BYTE PTR [rdi+7]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 4", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+8]", - "movzx r9d, BYTE PTR [rdi+9]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 5", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+10]", - "movzx r9d, BYTE PTR [rdi+11]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 6", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+12]", - "movzx r9d, BYTE PTR [rdi+13]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 7", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+14]", - "movzx r9d, BYTE PTR [rdi+15]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 8", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+16]", - "movzx r9d, BYTE PTR [rdi+17]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 9", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+18]", - "movzx r9d, BYTE PTR [rdi+19]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 10", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+20]", - "movzx r9d, BYTE PTR [rdi+21]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 11", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+22]", - "movzx r9d, BYTE PTR [rdi+23]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 12", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+24]", - "movzx r9d, BYTE PTR [rdi+25]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 13", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+26]", - "movzx r9d, BYTE PTR [rdi+27]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 14", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+28]", - "movzx r9d, BYTE PTR [rdi+29]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 15", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+30]", - "movzx r9d, BYTE PTR [rdi+31]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 16", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+32]", - "movzx r9d, BYTE PTR [rdi+33]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 17", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+34]", - "movzx r9d, BYTE PTR [rdi+35]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 18", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+36]", - "movzx r9d, BYTE PTR [rdi+37]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 19", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+38]", - "movzx r9d, BYTE PTR [rdi+39]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 20", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+40]", - "movzx r9d, BYTE PTR [rdi+41]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 21", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+42]", - "movzx r9d, BYTE PTR [rdi+43]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 22", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+44]", - "movzx r9d, BYTE PTR [rdi+45]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 23", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+46]", - "movzx r9d, BYTE PTR [rdi+47]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 24", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+48]", - "movzx r9d, BYTE PTR [rdi+49]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 25", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+50]", - "movzx r9d, BYTE PTR [rdi+51]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 26", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+52]", - "movzx r9d, BYTE PTR [rdi+53]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 27", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+54]", - "movzx r9d, BYTE PTR [rdi+55]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 28", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+56]", - "movzx r9d, BYTE PTR [rdi+57]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 29", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+58]", - "movzx r9d, BYTE PTR [rdi+59]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 30", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+60]", - "movzx r9d, BYTE PTR [rdi+61]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 31", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+62]", - "movzx r9d, BYTE PTR [rdi+63]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 32", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+64]", - "movzx r9d, BYTE PTR [rdi+65]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 33", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+66]", - "movzx r9d, BYTE PTR [rdi+67]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 34", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+68]", - "movzx r9d, BYTE PTR [rdi+69]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 35", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+70]", - "movzx r9d, BYTE PTR [rdi+71]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 36", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+72]", - "movzx r9d, BYTE PTR [rdi+73]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 37", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+74]", - "movzx r9d, BYTE PTR [rdi+75]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 38", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+76]", - "movzx r9d, BYTE PTR [rdi+77]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 39", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+78]", - "movzx r9d, BYTE PTR [rdi+79]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 40", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+80]", - "movzx r9d, BYTE PTR [rdi+81]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 41", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+82]", - "movzx r9d, BYTE PTR [rdi+83]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 42", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+84]", - "movzx r9d, BYTE PTR [rdi+85]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 43", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+86]", - "movzx r9d, BYTE PTR [rdi+87]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 44", - "sub r10, 1", - "sbb r10, r10", + "movq xmm0, rax", + "punpcklwd xmm0, xmm0", + "pshufd xmm0, xmm0, 0", + "pxor xmm1, xmm1", + "movabs r10, 844433520132096", + "movq xmm2, r10", + "movabs r10, 1970350607106052", + "movq xmm5, r10", + "punpcklqdq xmm2, xmm5", + "movabs r10, 281479271743489", + "movq xmm6, r10", + "movabs r10, 281479271743489", + "movq xmm5, r10", + "punpcklqdq xmm6, xmm5", + "movabs r10, 2251834173947912", + "movq xmm7, r10", + "movabs r10, 2251834173947912", + "movq xmm5, r10", + "punpcklqdq xmm7, xmm5", + "movdqu xmm4, XMMWORD PTR [rdi]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+16]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+32]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+48]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+64]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+80]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+96]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+112]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqa xmm3, xmm1", + "psrldq xmm3, 8", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 4", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 2", + "por xmm1, xmm3", + "movdqu XMMWORD PTR [rdx+64], xmm1", + "mov rax, QWORD PTR [rdx+64]", + "and rax, 65535", + "movdqu XMMWORD PTR [rdx+64], xmm8", + "add r15, rax", + "and r15, 65535", + "mov r10, r15", + "and r10, r14", + "mov r11, r15", + "xor r11, -1", + "and r11, r13", + "add r10, r11", "movzx r8d, BYTE PTR [rdi+88]", "movzx r9d, BYTE PTR [rdi+89]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 45", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+90]", - "movzx r9d, BYTE PTR [rdi+91]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 46", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+92]", - "movzx r9d, BYTE PTR [rdi+93]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 47", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+94]", - "movzx r9d, BYTE PTR [rdi+95]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 48", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+96]", - "movzx r9d, BYTE PTR [rdi+97]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 49", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+98]", - "movzx r9d, BYTE PTR [rdi+99]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 50", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+100]", - "movzx r9d, BYTE PTR [rdi+101]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 51", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+102]", - "movzx r9d, BYTE PTR [rdi+103]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 52", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+104]", - "movzx r9d, BYTE PTR [rdi+105]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 53", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+106]", - "movzx r9d, BYTE PTR [rdi+107]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 54", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+108]", - "movzx r9d, BYTE PTR [rdi+109]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 55", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+110]", - "movzx r9d, BYTE PTR [rdi+111]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 56", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+112]", - "movzx r9d, BYTE PTR [rdi+113]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 57", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+114]", - "movzx r9d, BYTE PTR [rdi+115]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 58", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+116]", - "movzx r9d, BYTE PTR [rdi+117]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 59", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+118]", - "movzx r9d, BYTE PTR [rdi+119]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 60", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+120]", - "movzx r9d, BYTE PTR [rdi+121]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 61", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+122]", - "movzx r9d, BYTE PTR [rdi+123]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 62", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+124]", - "movzx r9d, BYTE PTR [rdi+125]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 63", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+126]", - "movzx r9d, BYTE PTR [rdi+127]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov rax, rcx", - "sub r14, rax", - "and r14, 65535", + "add r12, r8", + "add r12, r10", + "and r12, 65535", "mov rax, r12", - "and rax, 63", - "mov rcx, 0", - "mov r10, rax", - "xor r10, 0", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi]", - "movzx r9d, BYTE PTR [rdi+1]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 1", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+2]", - "movzx r9d, BYTE PTR [rdi+3]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 2", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+4]", - "movzx r9d, BYTE PTR [rdi+5]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 3", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+6]", - "movzx r9d, BYTE PTR [rdi+7]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 4", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+8]", - "movzx r9d, BYTE PTR [rdi+9]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 5", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+10]", - "movzx r9d, BYTE PTR [rdi+11]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 6", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+12]", - "movzx r9d, BYTE PTR [rdi+13]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 7", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+14]", - "movzx r9d, BYTE PTR [rdi+15]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 8", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+16]", - "movzx r9d, BYTE PTR [rdi+17]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 9", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+18]", - "movzx r9d, BYTE PTR [rdi+19]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 10", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+20]", - "movzx r9d, BYTE PTR [rdi+21]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 11", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+22]", - "movzx r9d, BYTE PTR [rdi+23]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 12", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+24]", - "movzx r9d, BYTE PTR [rdi+25]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 13", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+26]", - "movzx r9d, BYTE PTR [rdi+27]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 14", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+28]", - "movzx r9d, BYTE PTR [rdi+29]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 15", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+30]", - "movzx r9d, BYTE PTR [rdi+31]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 16", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+32]", - "movzx r9d, BYTE PTR [rdi+33]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 17", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+34]", - "movzx r9d, BYTE PTR [rdi+35]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 18", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+36]", - "movzx r9d, BYTE PTR [rdi+37]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 19", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+38]", - "movzx r9d, BYTE PTR [rdi+39]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 20", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+40]", - "movzx r9d, BYTE PTR [rdi+41]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 21", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+42]", - "movzx r9d, BYTE PTR [rdi+43]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 22", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+44]", - "movzx r9d, BYTE PTR [rdi+45]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 23", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+46]", - "movzx r9d, BYTE PTR [rdi+47]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 24", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+48]", - "movzx r9d, BYTE PTR [rdi+49]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 25", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+50]", - "movzx r9d, BYTE PTR [rdi+51]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 26", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+52]", - "movzx r9d, BYTE PTR [rdi+53]", + "shr rax, 15", + "ror r12, 63", + "or r12, rax", + "and r12, 65535", + "mov r10, r12", + "and r10, r15", + "mov r11, r12", + "xor r11, -1", + "and r11, r14", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+90]", + "movzx r9d, BYTE PTR [rdi+91]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 27", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+54]", - "movzx r9d, BYTE PTR [rdi+55]", + "add r13, r8", + "add r13, r10", + "and r13, 65535", + "mov rax, r13", + "shr rax, 14", + "ror r13, 62", + "or r13, rax", + "and r13, 65535", + "mov r10, r13", + "and r10, r12", + "mov r11, r13", + "xor r11, -1", + "and r11, r15", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+92]", + "movzx r9d, BYTE PTR [rdi+93]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 28", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+56]", - "movzx r9d, BYTE PTR [rdi+57]", + "add r14, r8", + "add r14, r10", + "and r14, 65535", + "mov rax, r14", + "shr rax, 13", + "ror r14, 61", + "or r14, rax", + "and r14, 65535", + "mov r10, r14", + "and r10, r13", + "mov r11, r14", + "xor r11, -1", + "and r11, r12", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+94]", + "movzx r9d, BYTE PTR [rdi+95]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 29", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+58]", - "movzx r9d, BYTE PTR [rdi+59]", + "add r15, r8", + "add r15, r10", + "and r15, 65535", + "mov rax, r15", + "shr rax, 11", + "ror r15, 59", + "or r15, rax", + "and r15, 65535", + "mov r10, r15", + "and r10, r14", + "mov r11, r15", + "xor r11, -1", + "and r11, r13", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+96]", + "movzx r9d, BYTE PTR [rdi+97]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 30", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+60]", - "movzx r9d, BYTE PTR [rdi+61]", + "add r12, r8", + "add r12, r10", + "and r12, 65535", + "mov rax, r12", + "shr rax, 15", + "ror r12, 63", + "or r12, rax", + "and r12, 65535", + "mov r10, r12", + "and r10, r15", + "mov r11, r12", + "xor r11, -1", + "and r11, r14", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+98]", + "movzx r9d, BYTE PTR [rdi+99]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 31", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+62]", - "movzx r9d, BYTE PTR [rdi+63]", + "add r13, r8", + "add r13, r10", + "and r13, 65535", + "mov rax, r13", + "shr rax, 14", + "ror r13, 62", + "or r13, rax", + "and r13, 65535", + "mov r10, r13", + "and r10, r12", + "mov r11, r13", + "xor r11, -1", + "and r11, r15", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+100]", + "movzx r9d, BYTE PTR [rdi+101]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 32", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+64]", - "movzx r9d, BYTE PTR [rdi+65]", + "add r14, r8", + "add r14, r10", + "and r14, 65535", + "mov rax, r14", + "shr rax, 13", + "ror r14, 61", + "or r14, rax", + "and r14, 65535", + "mov r10, r14", + "and r10, r13", + "mov r11, r14", + "xor r11, -1", + "and r11, r12", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+102]", + "movzx r9d, BYTE PTR [rdi+103]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 33", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+66]", - "movzx r9d, BYTE PTR [rdi+67]", + "add r15, r8", + "add r15, r10", + "and r15, 65535", + "mov rax, r15", + "shr rax, 11", + "ror r15, 59", + "or r15, rax", + "and r15, 65535", + "mov r10, r15", + "and r10, r14", + "mov r11, r15", + "xor r11, -1", + "and r11, r13", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+104]", + "movzx r9d, BYTE PTR [rdi+105]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 34", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+68]", - "movzx r9d, BYTE PTR [rdi+69]", + "add r12, r8", + "add r12, r10", + "and r12, 65535", + "mov rax, r12", + "shr rax, 15", + "ror r12, 63", + "or r12, rax", + "and r12, 65535", + "mov r10, r12", + "and r10, r15", + "mov r11, r12", + "xor r11, -1", + "and r11, r14", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+106]", + "movzx r9d, BYTE PTR [rdi+107]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 35", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+70]", - "movzx r9d, BYTE PTR [rdi+71]", + "add r13, r8", + "add r13, r10", + "and r13, 65535", + "mov rax, r13", + "shr rax, 14", + "ror r13, 62", + "or r13, rax", + "and r13, 65535", + "mov r10, r13", + "and r10, r12", + "mov r11, r13", + "xor r11, -1", + "and r11, r15", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+108]", + "movzx r9d, BYTE PTR [rdi+109]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 36", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+72]", - "movzx r9d, BYTE PTR [rdi+73]", + "add r14, r8", + "add r14, r10", + "and r14, 65535", + "mov rax, r14", + "shr rax, 13", + "ror r14, 61", + "or r14, rax", + "and r14, 65535", + "mov r10, r14", + "and r10, r13", + "mov r11, r14", + "xor r11, -1", + "and r11, r12", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+110]", + "movzx r9d, BYTE PTR [rdi+111]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 37", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+74]", - "movzx r9d, BYTE PTR [rdi+75]", + "add r15, r8", + "add r15, r10", + "and r15, 65535", + "mov rax, r15", + "shr rax, 11", + "ror r15, 59", + "or r15, rax", + "and r15, 65535", + "mov r10, r15", + "and r10, r14", + "mov r11, r15", + "xor r11, -1", + "and r11, r13", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+112]", + "movzx r9d, BYTE PTR [rdi+113]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 38", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+76]", - "movzx r9d, BYTE PTR [rdi+77]", + "add r12, r8", + "add r12, r10", + "and r12, 65535", + "mov rax, r12", + "shr rax, 15", + "ror r12, 63", + "or r12, rax", + "and r12, 65535", + "mov r10, r12", + "and r10, r15", + "mov r11, r12", + "xor r11, -1", + "and r11, r14", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+114]", + "movzx r9d, BYTE PTR [rdi+115]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 39", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+78]", - "movzx r9d, BYTE PTR [rdi+79]", + "add r13, r8", + "add r13, r10", + "and r13, 65535", + "mov rax, r13", + "shr rax, 14", + "ror r13, 62", + "or r13, rax", + "and r13, 65535", + "mov r10, r13", + "and r10, r12", + "mov r11, r13", + "xor r11, -1", + "and r11, r15", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+116]", + "movzx r9d, BYTE PTR [rdi+117]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 40", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+80]", - "movzx r9d, BYTE PTR [rdi+81]", + "add r14, r8", + "add r14, r10", + "and r14, 65535", + "mov rax, r14", + "shr rax, 13", + "ror r14, 61", + "or r14, rax", + "and r14, 65535", + "mov r10, r14", + "and r10, r13", + "mov r11, r14", + "xor r11, -1", + "and r11, r12", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+118]", + "movzx r9d, BYTE PTR [rdi+119]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 41", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+82]", - "movzx r9d, BYTE PTR [rdi+83]", + "add r15, r8", + "add r15, r10", + "and r15, 65535", + "mov rax, r15", + "shr rax, 11", + "ror r15, 59", + "or r15, rax", + "and r15, 65535", + "mov r10, r15", + "and r10, r14", + "mov r11, r15", + "xor r11, -1", + "and r11, r13", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+120]", + "movzx r9d, BYTE PTR [rdi+121]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 42", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+84]", - "movzx r9d, BYTE PTR [rdi+85]", + "add r12, r8", + "add r12, r10", + "and r12, 65535", + "mov rax, r12", + "shr rax, 15", + "ror r12, 63", + "or r12, rax", + "and r12, 65535", + "mov r10, r12", + "and r10, r15", + "mov r11, r12", + "xor r11, -1", + "and r11, r14", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+122]", + "movzx r9d, BYTE PTR [rdi+123]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 43", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+86]", - "movzx r9d, BYTE PTR [rdi+87]", + "add r13, r8", + "add r13, r10", + "and r13, 65535", + "mov rax, r13", + "shr rax, 14", + "ror r13, 62", + "or r13, rax", + "and r13, 65535", + "mov r10, r13", + "and r10, r12", + "mov r11, r13", + "xor r11, -1", + "and r11, r15", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+124]", + "movzx r9d, BYTE PTR [rdi+125]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 44", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+88]", - "movzx r9d, BYTE PTR [rdi+89]", + "add r14, r8", + "add r14, r10", + "and r14, 65535", + "mov rax, r14", + "shr rax, 13", + "ror r14, 61", + "or r14, rax", + "and r14, 65535", + "mov r10, r14", + "and r10, r13", + "mov r11, r14", + "xor r11, -1", + "and r11, r12", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+126]", + "movzx r9d, BYTE PTR [rdi+127]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 45", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+90]", - "movzx r9d, BYTE PTR [rdi+91]", + "add r15, r8", + "add r15, r10", + "and r15, 65535", + "mov rax, r15", + "shr rax, 11", + "ror r15, 59", + "or r15, rax", + "and r15, 65535", + "mov rax, r12", + "mov rcx, r13", + "ror rcx, 48", + "or rax, rcx", + "mov rcx, r14", + "ror rcx, 32", + "or rax, rcx", + "mov rcx, r15", + "ror rcx, 16", + "or rax, rcx", + "mov QWORD PTR [rsi], rax", + "mov r12, QWORD PTR [rdx]", + "mov r13, QWORD PTR [rdx+8]", + "mov r14, QWORD PTR [rdx+16]", + "mov r15, QWORD PTR [rdx+24]", + "ret", + ) +} + +/// RC2 block decryption (RFC 2268 §4): decrypts `*data` in place under `*schedule`, the 64 little-endian 16-bit words written by `vg_rc2_expand_key`. +/// +/// Contract: `VG.Spec.Rc2.decryptBlockContract`. Constant time: only pointers may affect timing, not the key schedule or data, including the reverse-mashing indices. +/// +/// Baseline x86-64 SSE2. Reverse mashing scans all 64 schedule words in a fixed order, eight words per vector. +/// +/// # Safety +/// +/// * `schedule` must be valid for reads of 128 bytes. +/// * `data` must be valid for reads and writes of 8 bytes. +/// * `scratch` must be valid for reads and writes of 256 bytes. +/// * The contents of `scratch` on return are unspecified. +/// * `data` and `scratch` must not overlap each other or `schedule` (distinct Rust objects never do). +/// * None of `schedule`, `data` and `scratch` may overlap the return address on the stack, or wrap around the end of the address space (no Rust object does). +#[unsafe(naked)] +pub(crate) unsafe extern "sysv64" fn vg_rc2_decrypt_block(schedule: *const [u8; 128], data: *mut [u8; 8], scratch: *mut [u64; 32]) { + core::arch::naked_asm!( + "mov QWORD PTR [rdx], r12", + "mov QWORD PTR [rdx+8], r13", + "mov QWORD PTR [rdx+16], r14", + "mov QWORD PTR [rdx+24], r15", + "mov rax, QWORD PTR [rsi]", + "mov r12, rax", + "and r12, 65535", + "mov r13, rax", + "shr r13, 16", + "and r13, 65535", + "mov r14, rax", + "shr r14, 32", + "and r14, 65535", + "mov r15, rax", + "shr r15, 48", + "and r15, 65535", + "mov rax, r15", + "shr rax, 5", + "ror r15, 53", + "or r15, rax", + "and r15, 65535", + "mov r10, r14", + "and r10, r13", + "mov r11, r14", + "xor r11, -1", + "and r11, r12", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+126]", + "movzx r9d, BYTE PTR [rdi+127]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 46", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+92]", - "movzx r9d, BYTE PTR [rdi+93]", + "sub r15, r8", + "sub r15, r10", + "and r15, 65535", + "mov rax, r14", + "shr rax, 3", + "ror r14, 51", + "or r14, rax", + "and r14, 65535", + "mov r10, r13", + "and r10, r12", + "mov r11, r13", + "xor r11, -1", + "and r11, r15", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+124]", + "movzx r9d, BYTE PTR [rdi+125]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 47", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+94]", - "movzx r9d, BYTE PTR [rdi+95]", + "sub r14, r8", + "sub r14, r10", + "and r14, 65535", + "mov rax, r13", + "shr rax, 2", + "ror r13, 50", + "or r13, rax", + "and r13, 65535", + "mov r10, r12", + "and r10, r15", + "mov r11, r12", + "xor r11, -1", + "and r11, r14", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+122]", + "movzx r9d, BYTE PTR [rdi+123]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 48", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+96]", - "movzx r9d, BYTE PTR [rdi+97]", + "sub r13, r8", + "sub r13, r10", + "and r13, 65535", + "mov rax, r12", + "shr rax, 1", + "ror r12, 49", + "or r12, rax", + "and r12, 65535", + "mov r10, r15", + "and r10, r14", + "mov r11, r15", + "xor r11, -1", + "and r11, r13", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+120]", + "movzx r9d, BYTE PTR [rdi+121]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 49", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+98]", - "movzx r9d, BYTE PTR [rdi+99]", + "sub r12, r8", + "sub r12, r10", + "and r12, 65535", + "mov rax, r15", + "shr rax, 5", + "ror r15, 53", + "or r15, rax", + "and r15, 65535", + "mov r10, r14", + "and r10, r13", + "mov r11, r14", + "xor r11, -1", + "and r11, r12", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+118]", + "movzx r9d, BYTE PTR [rdi+119]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 50", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+100]", - "movzx r9d, BYTE PTR [rdi+101]", + "sub r15, r8", + "sub r15, r10", + "and r15, 65535", + "mov rax, r14", + "shr rax, 3", + "ror r14, 51", + "or r14, rax", + "and r14, 65535", + "mov r10, r13", + "and r10, r12", + "mov r11, r13", + "xor r11, -1", + "and r11, r15", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+116]", + "movzx r9d, BYTE PTR [rdi+117]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 51", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+102]", - "movzx r9d, BYTE PTR [rdi+103]", + "sub r14, r8", + "sub r14, r10", + "and r14, 65535", + "mov rax, r13", + "shr rax, 2", + "ror r13, 50", + "or r13, rax", + "and r13, 65535", + "mov r10, r12", + "and r10, r15", + "mov r11, r12", + "xor r11, -1", + "and r11, r14", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+114]", + "movzx r9d, BYTE PTR [rdi+115]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 52", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+104]", - "movzx r9d, BYTE PTR [rdi+105]", + "sub r13, r8", + "sub r13, r10", + "and r13, 65535", + "mov rax, r12", + "shr rax, 1", + "ror r12, 49", + "or r12, rax", + "and r12, 65535", + "mov r10, r15", + "and r10, r14", + "mov r11, r15", + "xor r11, -1", + "and r11, r13", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+112]", + "movzx r9d, BYTE PTR [rdi+113]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 53", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+106]", - "movzx r9d, BYTE PTR [rdi+107]", + "sub r12, r8", + "sub r12, r10", + "and r12, 65535", + "mov rax, r15", + "shr rax, 5", + "ror r15, 53", + "or r15, rax", + "and r15, 65535", + "mov r10, r14", + "and r10, r13", + "mov r11, r14", + "xor r11, -1", + "and r11, r12", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+110]", + "movzx r9d, BYTE PTR [rdi+111]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 54", - "sub r10, 1", - "sbb r10, r10", + "sub r15, r8", + "sub r15, r10", + "and r15, 65535", + "mov rax, r14", + "shr rax, 3", + "ror r14, 51", + "or r14, rax", + "and r14, 65535", + "mov r10, r13", + "and r10, r12", + "mov r11, r13", + "xor r11, -1", + "and r11, r15", + "add r10, r11", "movzx r8d, BYTE PTR [rdi+108]", "movzx r9d, BYTE PTR [rdi+109]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 55", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+110]", - "movzx r9d, BYTE PTR [rdi+111]", + "sub r14, r8", + "sub r14, r10", + "and r14, 65535", + "mov rax, r13", + "shr rax, 2", + "ror r13, 50", + "or r13, rax", + "and r13, 65535", + "mov r10, r12", + "and r10, r15", + "mov r11, r12", + "xor r11, -1", + "and r11, r14", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+106]", + "movzx r9d, BYTE PTR [rdi+107]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 56", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+112]", - "movzx r9d, BYTE PTR [rdi+113]", + "sub r13, r8", + "sub r13, r10", + "and r13, 65535", + "mov rax, r12", + "shr rax, 1", + "ror r12, 49", + "or r12, rax", + "and r12, 65535", + "mov r10, r15", + "and r10, r14", + "mov r11, r15", + "xor r11, -1", + "and r11, r13", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+104]", + "movzx r9d, BYTE PTR [rdi+105]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 57", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+114]", - "movzx r9d, BYTE PTR [rdi+115]", + "sub r12, r8", + "sub r12, r10", + "and r12, 65535", + "mov rax, r15", + "shr rax, 5", + "ror r15, 53", + "or r15, rax", + "and r15, 65535", + "mov r10, r14", + "and r10, r13", + "mov r11, r14", + "xor r11, -1", + "and r11, r12", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+102]", + "movzx r9d, BYTE PTR [rdi+103]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 58", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+116]", - "movzx r9d, BYTE PTR [rdi+117]", + "sub r15, r8", + "sub r15, r10", + "and r15, 65535", + "mov rax, r14", + "shr rax, 3", + "ror r14, 51", + "or r14, rax", + "and r14, 65535", + "mov r10, r13", + "and r10, r12", + "mov r11, r13", + "xor r11, -1", + "and r11, r15", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+100]", + "movzx r9d, BYTE PTR [rdi+101]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 59", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+118]", - "movzx r9d, BYTE PTR [rdi+119]", + "sub r14, r8", + "sub r14, r10", + "and r14, 65535", + "mov rax, r13", + "shr rax, 2", + "ror r13, 50", + "or r13, rax", + "and r13, 65535", + "mov r10, r12", + "and r10, r15", + "mov r11, r12", + "xor r11, -1", + "and r11, r14", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+98]", + "movzx r9d, BYTE PTR [rdi+99]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 60", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+120]", - "movzx r9d, BYTE PTR [rdi+121]", + "sub r13, r8", + "sub r13, r10", + "and r13, 65535", + "mov rax, r12", + "shr rax, 1", + "ror r12, 49", + "or r12, rax", + "and r12, 65535", + "mov r10, r15", + "and r10, r14", + "mov r11, r15", + "xor r11, -1", + "and r11, r13", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+96]", + "movzx r9d, BYTE PTR [rdi+97]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 61", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+122]", - "movzx r9d, BYTE PTR [rdi+123]", + "sub r12, r8", + "sub r12, r10", + "and r12, 65535", + "mov rax, r15", + "shr rax, 5", + "ror r15, 53", + "or r15, rax", + "and r15, 65535", + "mov r10, r14", + "and r10, r13", + "mov r11, r14", + "xor r11, -1", + "and r11, r12", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+94]", + "movzx r9d, BYTE PTR [rdi+95]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 62", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+124]", - "movzx r9d, BYTE PTR [rdi+125]", + "sub r15, r8", + "sub r15, r10", + "and r15, 65535", + "mov rax, r14", + "shr rax, 3", + "ror r14, 51", + "or r14, rax", + "and r14, 65535", + "mov r10, r13", + "and r10, r12", + "mov r11, r13", + "xor r11, -1", + "and r11, r15", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+92]", + "movzx r9d, BYTE PTR [rdi+93]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 63", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+126]", - "movzx r9d, BYTE PTR [rdi+127]", + "sub r14, r8", + "sub r14, r10", + "and r14, 65535", + "mov rax, r13", + "shr rax, 2", + "ror r13, 50", + "or r13, rax", + "and r13, 65535", + "mov r10, r12", + "and r10, r15", + "mov r11, r12", + "xor r11, -1", + "and r11, r14", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+90]", + "movzx r9d, BYTE PTR [rdi+91]", + "ror r9, 56", + "or r8, r9", + "sub r13, r8", + "sub r13, r10", + "and r13, 65535", + "mov rax, r12", + "shr rax, 1", + "ror r12, 49", + "or r12, rax", + "and r12, 65535", + "mov r10, r15", + "and r10, r14", + "mov r11, r15", + "xor r11, -1", + "and r11, r13", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+88]", + "movzx r9d, BYTE PTR [rdi+89]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov rax, rcx", + "sub r12, r8", + "sub r12, r10", + "and r12, 65535", + "mov rax, r14", + "movdqu xmm8, XMMWORD PTR [rdx+64]", + "and rax, 63", + "movq xmm0, rax", + "punpcklwd xmm0, xmm0", + "pshufd xmm0, xmm0, 0", + "pxor xmm1, xmm1", + "movabs r10, 844433520132096", + "movq xmm2, r10", + "movabs r10, 1970350607106052", + "movq xmm5, r10", + "punpcklqdq xmm2, xmm5", + "movabs r10, 281479271743489", + "movq xmm6, r10", + "movabs r10, 281479271743489", + "movq xmm5, r10", + "punpcklqdq xmm6, xmm5", + "movabs r10, 2251834173947912", + "movq xmm7, r10", + "movabs r10, 2251834173947912", + "movq xmm5, r10", + "punpcklqdq xmm7, xmm5", + "movdqu xmm4, XMMWORD PTR [rdi]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+16]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+32]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+48]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+64]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+80]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+96]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+112]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqa xmm3, xmm1", + "psrldq xmm3, 8", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 4", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 2", + "por xmm1, xmm3", + "movdqu XMMWORD PTR [rdx+64], xmm1", + "mov rax, QWORD PTR [rdx+64]", + "and rax, 65535", + "movdqu XMMWORD PTR [rdx+64], xmm8", + "sub r15, rax", + "and r15, 65535", + "mov rax, r13", + "movdqu xmm8, XMMWORD PTR [rdx+64]", + "and rax, 63", + "movq xmm0, rax", + "punpcklwd xmm0, xmm0", + "pshufd xmm0, xmm0, 0", + "pxor xmm1, xmm1", + "movabs r10, 844433520132096", + "movq xmm2, r10", + "movabs r10, 1970350607106052", + "movq xmm5, r10", + "punpcklqdq xmm2, xmm5", + "movabs r10, 281479271743489", + "movq xmm6, r10", + "movabs r10, 281479271743489", + "movq xmm5, r10", + "punpcklqdq xmm6, xmm5", + "movabs r10, 2251834173947912", + "movq xmm7, r10", + "movabs r10, 2251834173947912", + "movq xmm5, r10", + "punpcklqdq xmm7, xmm5", + "movdqu xmm4, XMMWORD PTR [rdi]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+16]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+32]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+48]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+64]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+80]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+96]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+112]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqa xmm3, xmm1", + "psrldq xmm3, 8", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 4", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 2", + "por xmm1, xmm3", + "movdqu XMMWORD PTR [rdx+64], xmm1", + "mov rax, QWORD PTR [rdx+64]", + "and rax, 65535", + "movdqu XMMWORD PTR [rdx+64], xmm8", + "sub r14, rax", + "and r14, 65535", + "mov rax, r12", + "movdqu xmm8, XMMWORD PTR [rdx+64]", + "and rax, 63", + "movq xmm0, rax", + "punpcklwd xmm0, xmm0", + "pshufd xmm0, xmm0, 0", + "pxor xmm1, xmm1", + "movabs r10, 844433520132096", + "movq xmm2, r10", + "movabs r10, 1970350607106052", + "movq xmm5, r10", + "punpcklqdq xmm2, xmm5", + "movabs r10, 281479271743489", + "movq xmm6, r10", + "movabs r10, 281479271743489", + "movq xmm5, r10", + "punpcklqdq xmm6, xmm5", + "movabs r10, 2251834173947912", + "movq xmm7, r10", + "movabs r10, 2251834173947912", + "movq xmm5, r10", + "punpcklqdq xmm7, xmm5", + "movdqu xmm4, XMMWORD PTR [rdi]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+16]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+32]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+48]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+64]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+80]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+96]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+112]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqa xmm3, xmm1", + "psrldq xmm3, 8", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 4", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 2", + "por xmm1, xmm3", + "movdqu XMMWORD PTR [rdx+64], xmm1", + "mov rax, QWORD PTR [rdx+64]", + "and rax, 65535", + "movdqu XMMWORD PTR [rdx+64], xmm8", "sub r13, rax", "and r13, 65535", "mov rax, r15", - "and rax, 63", - "mov rcx, 0", - "mov r10, rax", - "xor r10, 0", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi]", - "movzx r9d, BYTE PTR [rdi+1]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 1", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+2]", - "movzx r9d, BYTE PTR [rdi+3]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 2", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+4]", - "movzx r9d, BYTE PTR [rdi+5]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 3", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+6]", - "movzx r9d, BYTE PTR [rdi+7]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 4", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+8]", - "movzx r9d, BYTE PTR [rdi+9]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 5", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+10]", - "movzx r9d, BYTE PTR [rdi+11]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 6", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+12]", - "movzx r9d, BYTE PTR [rdi+13]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 7", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+14]", - "movzx r9d, BYTE PTR [rdi+15]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 8", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+16]", - "movzx r9d, BYTE PTR [rdi+17]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 9", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+18]", - "movzx r9d, BYTE PTR [rdi+19]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 10", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+20]", - "movzx r9d, BYTE PTR [rdi+21]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 11", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+22]", - "movzx r9d, BYTE PTR [rdi+23]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 12", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+24]", - "movzx r9d, BYTE PTR [rdi+25]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 13", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+26]", - "movzx r9d, BYTE PTR [rdi+27]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 14", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+28]", - "movzx r9d, BYTE PTR [rdi+29]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 15", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+30]", - "movzx r9d, BYTE PTR [rdi+31]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 16", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+32]", - "movzx r9d, BYTE PTR [rdi+33]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 17", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+34]", - "movzx r9d, BYTE PTR [rdi+35]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 18", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+36]", - "movzx r9d, BYTE PTR [rdi+37]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 19", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+38]", - "movzx r9d, BYTE PTR [rdi+39]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 20", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+40]", - "movzx r9d, BYTE PTR [rdi+41]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 21", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+42]", - "movzx r9d, BYTE PTR [rdi+43]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 22", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+44]", - "movzx r9d, BYTE PTR [rdi+45]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 23", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+46]", - "movzx r9d, BYTE PTR [rdi+47]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 24", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+48]", - "movzx r9d, BYTE PTR [rdi+49]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 25", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+50]", - "movzx r9d, BYTE PTR [rdi+51]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 26", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+52]", - "movzx r9d, BYTE PTR [rdi+53]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 27", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+54]", - "movzx r9d, BYTE PTR [rdi+55]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 28", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+56]", - "movzx r9d, BYTE PTR [rdi+57]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 29", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+58]", - "movzx r9d, BYTE PTR [rdi+59]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 30", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+60]", - "movzx r9d, BYTE PTR [rdi+61]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 31", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+62]", - "movzx r9d, BYTE PTR [rdi+63]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 32", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+64]", - "movzx r9d, BYTE PTR [rdi+65]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 33", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+66]", - "movzx r9d, BYTE PTR [rdi+67]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 34", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+68]", - "movzx r9d, BYTE PTR [rdi+69]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 35", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+70]", - "movzx r9d, BYTE PTR [rdi+71]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 36", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+72]", - "movzx r9d, BYTE PTR [rdi+73]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 37", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+74]", - "movzx r9d, BYTE PTR [rdi+75]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 38", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+76]", - "movzx r9d, BYTE PTR [rdi+77]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 39", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+78]", - "movzx r9d, BYTE PTR [rdi+79]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 40", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+80]", - "movzx r9d, BYTE PTR [rdi+81]", - "ror r9, 56", - "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 41", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+82]", - "movzx r9d, BYTE PTR [rdi+83]", + "movdqu xmm8, XMMWORD PTR [rdx+64]", + "and rax, 63", + "movq xmm0, rax", + "punpcklwd xmm0, xmm0", + "pshufd xmm0, xmm0, 0", + "pxor xmm1, xmm1", + "movabs r10, 844433520132096", + "movq xmm2, r10", + "movabs r10, 1970350607106052", + "movq xmm5, r10", + "punpcklqdq xmm2, xmm5", + "movabs r10, 281479271743489", + "movq xmm6, r10", + "movabs r10, 281479271743489", + "movq xmm5, r10", + "punpcklqdq xmm6, xmm5", + "movabs r10, 2251834173947912", + "movq xmm7, r10", + "movabs r10, 2251834173947912", + "movq xmm5, r10", + "punpcklqdq xmm7, xmm5", + "movdqu xmm4, XMMWORD PTR [rdi]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+16]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+32]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+48]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+64]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+80]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+96]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+112]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqa xmm3, xmm1", + "psrldq xmm3, 8", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 4", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 2", + "por xmm1, xmm3", + "movdqu XMMWORD PTR [rdx+64], xmm1", + "mov rax, QWORD PTR [rdx+64]", + "and rax, 65535", + "movdqu XMMWORD PTR [rdx+64], xmm8", + "sub r12, rax", + "and r12, 65535", + "mov rax, r15", + "shr rax, 5", + "ror r15, 53", + "or r15, rax", + "and r15, 65535", + "mov r10, r14", + "and r10, r13", + "mov r11, r14", + "xor r11, -1", + "and r11, r12", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+86]", + "movzx r9d, BYTE PTR [rdi+87]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 42", - "sub r10, 1", - "sbb r10, r10", + "sub r15, r8", + "sub r15, r10", + "and r15, 65535", + "mov rax, r14", + "shr rax, 3", + "ror r14, 51", + "or r14, rax", + "and r14, 65535", + "mov r10, r13", + "and r10, r12", + "mov r11, r13", + "xor r11, -1", + "and r11, r15", + "add r10, r11", "movzx r8d, BYTE PTR [rdi+84]", "movzx r9d, BYTE PTR [rdi+85]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 43", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+86]", - "movzx r9d, BYTE PTR [rdi+87]", + "sub r14, r8", + "sub r14, r10", + "and r14, 65535", + "mov rax, r13", + "shr rax, 2", + "ror r13, 50", + "or r13, rax", + "and r13, 65535", + "mov r10, r12", + "and r10, r15", + "mov r11, r12", + "xor r11, -1", + "and r11, r14", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+82]", + "movzx r9d, BYTE PTR [rdi+83]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 44", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+88]", - "movzx r9d, BYTE PTR [rdi+89]", + "sub r13, r8", + "sub r13, r10", + "and r13, 65535", + "mov rax, r12", + "shr rax, 1", + "ror r12, 49", + "or r12, rax", + "and r12, 65535", + "mov r10, r15", + "and r10, r14", + "mov r11, r15", + "xor r11, -1", + "and r11, r13", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+80]", + "movzx r9d, BYTE PTR [rdi+81]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 45", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+90]", - "movzx r9d, BYTE PTR [rdi+91]", + "sub r12, r8", + "sub r12, r10", + "and r12, 65535", + "mov rax, r15", + "shr rax, 5", + "ror r15, 53", + "or r15, rax", + "and r15, 65535", + "mov r10, r14", + "and r10, r13", + "mov r11, r14", + "xor r11, -1", + "and r11, r12", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+78]", + "movzx r9d, BYTE PTR [rdi+79]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 46", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+92]", - "movzx r9d, BYTE PTR [rdi+93]", + "sub r15, r8", + "sub r15, r10", + "and r15, 65535", + "mov rax, r14", + "shr rax, 3", + "ror r14, 51", + "or r14, rax", + "and r14, 65535", + "mov r10, r13", + "and r10, r12", + "mov r11, r13", + "xor r11, -1", + "and r11, r15", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+76]", + "movzx r9d, BYTE PTR [rdi+77]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 47", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+94]", - "movzx r9d, BYTE PTR [rdi+95]", + "sub r14, r8", + "sub r14, r10", + "and r14, 65535", + "mov rax, r13", + "shr rax, 2", + "ror r13, 50", + "or r13, rax", + "and r13, 65535", + "mov r10, r12", + "and r10, r15", + "mov r11, r12", + "xor r11, -1", + "and r11, r14", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+74]", + "movzx r9d, BYTE PTR [rdi+75]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 48", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+96]", - "movzx r9d, BYTE PTR [rdi+97]", + "sub r13, r8", + "sub r13, r10", + "and r13, 65535", + "mov rax, r12", + "shr rax, 1", + "ror r12, 49", + "or r12, rax", + "and r12, 65535", + "mov r10, r15", + "and r10, r14", + "mov r11, r15", + "xor r11, -1", + "and r11, r13", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+72]", + "movzx r9d, BYTE PTR [rdi+73]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 49", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+98]", - "movzx r9d, BYTE PTR [rdi+99]", + "sub r12, r8", + "sub r12, r10", + "and r12, 65535", + "mov rax, r15", + "shr rax, 5", + "ror r15, 53", + "or r15, rax", + "and r15, 65535", + "mov r10, r14", + "and r10, r13", + "mov r11, r14", + "xor r11, -1", + "and r11, r12", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+70]", + "movzx r9d, BYTE PTR [rdi+71]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 50", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+100]", - "movzx r9d, BYTE PTR [rdi+101]", + "sub r15, r8", + "sub r15, r10", + "and r15, 65535", + "mov rax, r14", + "shr rax, 3", + "ror r14, 51", + "or r14, rax", + "and r14, 65535", + "mov r10, r13", + "and r10, r12", + "mov r11, r13", + "xor r11, -1", + "and r11, r15", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+68]", + "movzx r9d, BYTE PTR [rdi+69]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 51", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+102]", - "movzx r9d, BYTE PTR [rdi+103]", + "sub r14, r8", + "sub r14, r10", + "and r14, 65535", + "mov rax, r13", + "shr rax, 2", + "ror r13, 50", + "or r13, rax", + "and r13, 65535", + "mov r10, r12", + "and r10, r15", + "mov r11, r12", + "xor r11, -1", + "and r11, r14", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+66]", + "movzx r9d, BYTE PTR [rdi+67]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 52", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+104]", - "movzx r9d, BYTE PTR [rdi+105]", + "sub r13, r8", + "sub r13, r10", + "and r13, 65535", + "mov rax, r12", + "shr rax, 1", + "ror r12, 49", + "or r12, rax", + "and r12, 65535", + "mov r10, r15", + "and r10, r14", + "mov r11, r15", + "xor r11, -1", + "and r11, r13", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+64]", + "movzx r9d, BYTE PTR [rdi+65]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 53", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+106]", - "movzx r9d, BYTE PTR [rdi+107]", + "sub r12, r8", + "sub r12, r10", + "and r12, 65535", + "mov rax, r15", + "shr rax, 5", + "ror r15, 53", + "or r15, rax", + "and r15, 65535", + "mov r10, r14", + "and r10, r13", + "mov r11, r14", + "xor r11, -1", + "and r11, r12", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+62]", + "movzx r9d, BYTE PTR [rdi+63]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 54", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+108]", - "movzx r9d, BYTE PTR [rdi+109]", + "sub r15, r8", + "sub r15, r10", + "and r15, 65535", + "mov rax, r14", + "shr rax, 3", + "ror r14, 51", + "or r14, rax", + "and r14, 65535", + "mov r10, r13", + "and r10, r12", + "mov r11, r13", + "xor r11, -1", + "and r11, r15", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+60]", + "movzx r9d, BYTE PTR [rdi+61]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 55", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+110]", - "movzx r9d, BYTE PTR [rdi+111]", + "sub r14, r8", + "sub r14, r10", + "and r14, 65535", + "mov rax, r13", + "shr rax, 2", + "ror r13, 50", + "or r13, rax", + "and r13, 65535", + "mov r10, r12", + "and r10, r15", + "mov r11, r12", + "xor r11, -1", + "and r11, r14", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+58]", + "movzx r9d, BYTE PTR [rdi+59]", + "ror r9, 56", + "or r8, r9", + "sub r13, r8", + "sub r13, r10", + "and r13, 65535", + "mov rax, r12", + "shr rax, 1", + "ror r12, 49", + "or r12, rax", + "and r12, 65535", + "mov r10, r15", + "and r10, r14", + "mov r11, r15", + "xor r11, -1", + "and r11, r13", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+56]", + "movzx r9d, BYTE PTR [rdi+57]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 56", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+112]", - "movzx r9d, BYTE PTR [rdi+113]", + "sub r12, r8", + "sub r12, r10", + "and r12, 65535", + "mov rax, r15", + "shr rax, 5", + "ror r15, 53", + "or r15, rax", + "and r15, 65535", + "mov r10, r14", + "and r10, r13", + "mov r11, r14", + "xor r11, -1", + "and r11, r12", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+54]", + "movzx r9d, BYTE PTR [rdi+55]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 57", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+114]", - "movzx r9d, BYTE PTR [rdi+115]", + "sub r15, r8", + "sub r15, r10", + "and r15, 65535", + "mov rax, r14", + "shr rax, 3", + "ror r14, 51", + "or r14, rax", + "and r14, 65535", + "mov r10, r13", + "and r10, r12", + "mov r11, r13", + "xor r11, -1", + "and r11, r15", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+52]", + "movzx r9d, BYTE PTR [rdi+53]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 58", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+116]", - "movzx r9d, BYTE PTR [rdi+117]", + "sub r14, r8", + "sub r14, r10", + "and r14, 65535", + "mov rax, r13", + "shr rax, 2", + "ror r13, 50", + "or r13, rax", + "and r13, 65535", + "mov r10, r12", + "and r10, r15", + "mov r11, r12", + "xor r11, -1", + "and r11, r14", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+50]", + "movzx r9d, BYTE PTR [rdi+51]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 59", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+118]", - "movzx r9d, BYTE PTR [rdi+119]", + "sub r13, r8", + "sub r13, r10", + "and r13, 65535", + "mov rax, r12", + "shr rax, 1", + "ror r12, 49", + "or r12, rax", + "and r12, 65535", + "mov r10, r15", + "and r10, r14", + "mov r11, r15", + "xor r11, -1", + "and r11, r13", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+48]", + "movzx r9d, BYTE PTR [rdi+49]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 60", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+120]", - "movzx r9d, BYTE PTR [rdi+121]", + "sub r12, r8", + "sub r12, r10", + "and r12, 65535", + "mov rax, r15", + "shr rax, 5", + "ror r15, 53", + "or r15, rax", + "and r15, 65535", + "mov r10, r14", + "and r10, r13", + "mov r11, r14", + "xor r11, -1", + "and r11, r12", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+46]", + "movzx r9d, BYTE PTR [rdi+47]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 61", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+122]", - "movzx r9d, BYTE PTR [rdi+123]", + "sub r15, r8", + "sub r15, r10", + "and r15, 65535", + "mov rax, r14", + "shr rax, 3", + "ror r14, 51", + "or r14, rax", + "and r14, 65535", + "mov r10, r13", + "and r10, r12", + "mov r11, r13", + "xor r11, -1", + "and r11, r15", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+44]", + "movzx r9d, BYTE PTR [rdi+45]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 62", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+124]", - "movzx r9d, BYTE PTR [rdi+125]", + "sub r14, r8", + "sub r14, r10", + "and r14, 65535", + "mov rax, r13", + "shr rax, 2", + "ror r13, 50", + "or r13, rax", + "and r13, 65535", + "mov r10, r12", + "and r10, r15", + "mov r11, r12", + "xor r11, -1", + "and r11, r14", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+42]", + "movzx r9d, BYTE PTR [rdi+43]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov r10, rax", - "xor r10, 63", - "sub r10, 1", - "sbb r10, r10", - "movzx r8d, BYTE PTR [rdi+126]", - "movzx r9d, BYTE PTR [rdi+127]", + "sub r13, r8", + "sub r13, r10", + "and r13, 65535", + "mov rax, r12", + "shr rax, 1", + "ror r12, 49", + "or r12, rax", + "and r12, 65535", + "mov r10, r15", + "and r10, r14", + "mov r11, r15", + "xor r11, -1", + "and r11, r13", + "add r10, r11", + "movzx r8d, BYTE PTR [rdi+40]", + "movzx r9d, BYTE PTR [rdi+41]", "ror r9, 56", "or r8, r9", - "and r8, r10", - "or rcx, r8", - "mov rax, rcx", + "sub r12, r8", + "sub r12, r10", + "and r12, 65535", + "mov rax, r14", + "movdqu xmm8, XMMWORD PTR [rdx+64]", + "and rax, 63", + "movq xmm0, rax", + "punpcklwd xmm0, xmm0", + "pshufd xmm0, xmm0, 0", + "pxor xmm1, xmm1", + "movabs r10, 844433520132096", + "movq xmm2, r10", + "movabs r10, 1970350607106052", + "movq xmm5, r10", + "punpcklqdq xmm2, xmm5", + "movabs r10, 281479271743489", + "movq xmm6, r10", + "movabs r10, 281479271743489", + "movq xmm5, r10", + "punpcklqdq xmm6, xmm5", + "movabs r10, 2251834173947912", + "movq xmm7, r10", + "movabs r10, 2251834173947912", + "movq xmm5, r10", + "punpcklqdq xmm7, xmm5", + "movdqu xmm4, XMMWORD PTR [rdi]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+16]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+32]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+48]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+64]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+80]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+96]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+112]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqa xmm3, xmm1", + "psrldq xmm3, 8", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 4", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 2", + "por xmm1, xmm3", + "movdqu XMMWORD PTR [rdx+64], xmm1", + "mov rax, QWORD PTR [rdx+64]", + "and rax, 65535", + "movdqu XMMWORD PTR [rdx+64], xmm8", + "sub r15, rax", + "and r15, 65535", + "mov rax, r13", + "movdqu xmm8, XMMWORD PTR [rdx+64]", + "and rax, 63", + "movq xmm0, rax", + "punpcklwd xmm0, xmm0", + "pshufd xmm0, xmm0, 0", + "pxor xmm1, xmm1", + "movabs r10, 844433520132096", + "movq xmm2, r10", + "movabs r10, 1970350607106052", + "movq xmm5, r10", + "punpcklqdq xmm2, xmm5", + "movabs r10, 281479271743489", + "movq xmm6, r10", + "movabs r10, 281479271743489", + "movq xmm5, r10", + "punpcklqdq xmm6, xmm5", + "movabs r10, 2251834173947912", + "movq xmm7, r10", + "movabs r10, 2251834173947912", + "movq xmm5, r10", + "punpcklqdq xmm7, xmm5", + "movdqu xmm4, XMMWORD PTR [rdi]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+16]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+32]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+48]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+64]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+80]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+96]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+112]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqa xmm3, xmm1", + "psrldq xmm3, 8", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 4", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 2", + "por xmm1, xmm3", + "movdqu XMMWORD PTR [rdx+64], xmm1", + "mov rax, QWORD PTR [rdx+64]", + "and rax, 65535", + "movdqu XMMWORD PTR [rdx+64], xmm8", + "sub r14, rax", + "and r14, 65535", + "mov rax, r12", + "movdqu xmm8, XMMWORD PTR [rdx+64]", + "and rax, 63", + "movq xmm0, rax", + "punpcklwd xmm0, xmm0", + "pshufd xmm0, xmm0, 0", + "pxor xmm1, xmm1", + "movabs r10, 844433520132096", + "movq xmm2, r10", + "movabs r10, 1970350607106052", + "movq xmm5, r10", + "punpcklqdq xmm2, xmm5", + "movabs r10, 281479271743489", + "movq xmm6, r10", + "movabs r10, 281479271743489", + "movq xmm5, r10", + "punpcklqdq xmm6, xmm5", + "movabs r10, 2251834173947912", + "movq xmm7, r10", + "movabs r10, 2251834173947912", + "movq xmm5, r10", + "punpcklqdq xmm7, xmm5", + "movdqu xmm4, XMMWORD PTR [rdi]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+16]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+32]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+48]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+64]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+80]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+96]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+112]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqa xmm3, xmm1", + "psrldq xmm3, 8", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 4", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 2", + "por xmm1, xmm3", + "movdqu XMMWORD PTR [rdx+64], xmm1", + "mov rax, QWORD PTR [rdx+64]", + "and rax, 65535", + "movdqu XMMWORD PTR [rdx+64], xmm8", + "sub r13, rax", + "and r13, 65535", + "mov rax, r15", + "movdqu xmm8, XMMWORD PTR [rdx+64]", + "and rax, 63", + "movq xmm0, rax", + "punpcklwd xmm0, xmm0", + "pshufd xmm0, xmm0, 0", + "pxor xmm1, xmm1", + "movabs r10, 844433520132096", + "movq xmm2, r10", + "movabs r10, 1970350607106052", + "movq xmm5, r10", + "punpcklqdq xmm2, xmm5", + "movabs r10, 281479271743489", + "movq xmm6, r10", + "movabs r10, 281479271743489", + "movq xmm5, r10", + "punpcklqdq xmm6, xmm5", + "movabs r10, 2251834173947912", + "movq xmm7, r10", + "movabs r10, 2251834173947912", + "movq xmm5, r10", + "punpcklqdq xmm7, xmm5", + "movdqu xmm4, XMMWORD PTR [rdi]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+16]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+32]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+48]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+64]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+80]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+96]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqu xmm4, XMMWORD PTR [rdi+112]", + "movdqa xmm3, xmm0", + "pxor xmm3, xmm2", + "psubw xmm3, xmm6", + "psraw xmm3, 15", + "pand xmm3, xmm4", + "por xmm1, xmm3", + "paddw xmm2, xmm7", + "movdqa xmm3, xmm1", + "psrldq xmm3, 8", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 4", + "por xmm1, xmm3", + "movdqa xmm3, xmm1", + "psrldq xmm3, 2", + "por xmm1, xmm3", + "movdqu XMMWORD PTR [rdx+64], xmm1", + "mov rax, QWORD PTR [rdx+64]", + "and rax, 65535", + "movdqu XMMWORD PTR [rdx+64], xmm8", "sub r12, rax", "and r12, 65535", "mov rax, r15",