val va_quick_Gf128MulRev128: Prims.unit -> (va_quickCode unit (va_code_Gf128MulRev128 ()))
let va_quick_Gf128MulRev128 () : (va_quickCode unit (va_code_Gf128MulRev128 ())) =
  (va_QProc (va_code_Gf128MulRev128 ()) ([va_Mod_vec 6; va_Mod_vec 5; va_Mod_vec 4; va_Mod_vec 3;
    va_Mod_vec 2; va_Mod_vec 1; va_Mod_vec 0; va_Mod_reg 10]) va_wp_Gf128MulRev128
    va_wpProof_Gf128MulRev128)
val va_quick_Gf128MulRev128: Prims.unit -> (va_quickCode unit (va_code_Gf128MulRev128 ()))
let va_quick_Gf128MulRev128 () : (va_quickCode unit (va_code_Gf128MulRev128 ())) =
(va_QProc (va_code_Gf128MulRev128 ())
    ([
        va_Mod_vec 6;
        va_Mod_vec 5;
        va_Mod_vec 4;
        va_Mod_vec 3;
        va_Mod_vec 2;
        va_Mod_vec 1;
        va_Mod_vec 0;
        va_Mod_reg 10
      ])
    va_wp_Gf128MulRev128
    va_wpProof_Gf128MulRev128)
Vale.AES.PPC64LE.GF128_Mul.fsti.checked
Vale.PPC64LE.State.fsti.checked Vale.PPC64LE.QuickCodes.fsti.checked Vale.PPC64LE.QuickCode.fst.checked Vale.PPC64LE.Machine_s.fst.checked Vale.PPC64LE.InsVector.fsti.checked Vale.PPC64LE.InsMem.fsti.checked Vale.PPC64LE.InsBasic.fsti.checked Vale.PPC64LE.Decls.fsti.checked Vale.Math.Poly2_s.fsti.checked Vale.Math.Poly2.Lemmas.fsti.checked Vale.Math.Poly2.Bits_s.fsti.checked Vale.Math.Poly2.Bits.fsti.checked Vale.Math.Poly2.fsti.checked Vale.Def.Words_s.fsti.checked Vale.Def.Types_s.fst.checked Vale.Arch.TypesNative.fsti.checked Vale.Arch.Types.fsti.checked Vale.AES.Types_helpers.fsti.checked Vale.AES.PPC64LE.PolyOps.fsti.checked Vale.AES.GHash_BE.fsti.checked Vale.AES.GF128_s.fsti.checked Vale.AES.GF128.fsti.checked prims.fst.checked FStar.Pervasives.Native.fst.checked FStar.Pervasives.fsti.checked
Vale.AES.PPC64LE.GF128_Mul.fsti
Prims.unit Vale.PPC64LE.QuickCode.va_QProc Vale.AES.PPC64LE.GF128_Mul.va_code_Gf128MulRev128 Prims.Cons Vale.PPC64LE.QuickCode.mod_t Vale.PPC64LE.QuickCode.va_Mod_vec Vale.PPC64LE.QuickCode.va_Mod_reg Prims.Nil Vale.AES.PPC64LE.GF128_Mul.va_wp_Gf128MulRev128 Vale.AES.PPC64LE.GF128_Mul.va_wpProof_Gf128MulRev128 Vale.PPC64LE.QuickCode.va_quickCode
module Vale.AES.PPC64LE.GF128_Mul
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Arch.TypesNative
open Vale.Math.Poly2_s
open Vale.Math.Poly2
open Vale.Math.Poly2.Bits_s
open Vale.Math.Poly2.Bits
open Vale.Math.Poly2.Lemmas
open Vale.AES.GF128_s
open Vale.AES.GF128
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.InsVector
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.QuickCodes
open Vale.AES.PPC64LE.PolyOps
open Vale.AES.Types_helpers
open Vale.AES.GHash_BE
//-- ShiftLeft128_1

val va_code_ShiftLeft128_1 : va_dummy:unit -> Tot va_code

val va_codegen_success_ShiftLeft128_1 : va_dummy:unit -> Tot va_pbool

val va_lemma_ShiftLeft128_1 : va_b0:va_code -> va_s0:va_state -> a:poly
  -> Ghost (va_state & va_fuel)
  (requires (va_require_total va_b0 (va_code_ShiftLeft128_1 ()) va_s0 /\ va_get_ok va_s0 /\
    Vale.Math.Poly2_s.degree a < 128 /\ va_get_vec 1 va_s0 == Vale.Math.Poly2.Bits_s.to_quad32 a))
  (ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
    va_get_vec 1 va_sM == Vale.Math.Poly2.Bits_s.to_quad32 (Vale.Math.Poly2_s.shift a 1) /\
    va_state_eq va_sM (va_update_vec 2 va_sM (va_update_vec 1 va_sM (va_update_ok va_sM va_s0)))))
[@ va_qattr]
let va_wp_ShiftLeft128_1 (a:poly) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
  (va_get_ok va_s0 /\ Vale.Math.Poly2_s.degree a < 128 /\ va_get_vec 1 va_s0 ==
    Vale.Math.Poly2.Bits_s.to_quad32 a /\ (forall (va_x_v1:quad32) (va_x_v2:quad32) . let va_sM =
    va_upd_vec 2 va_x_v2 (va_upd_vec 1 va_x_v1 va_s0) in va_get_ok va_sM /\ va_get_vec 1 va_sM ==
    Vale.Math.Poly2.Bits_s.to_quad32 (Vale.Math.Poly2_s.shift a 1) ==> va_k va_sM (())))

val va_wpProof_ShiftLeft128_1 : a:poly -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
  -> Ghost (va_state & va_fuel & unit)
  (requires (va_t_require va_s0 /\ va_wp_ShiftLeft128_1 a va_s0 va_k))
  (ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_ShiftLeft128_1 ()) ([va_Mod_vec 2;
    va_Mod_vec 1]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_ShiftLeft128_1 (a:poly) : (va_quickCode unit (va_code_ShiftLeft128_1 ())) =
  (va_QProc (va_code_ShiftLeft128_1 ()) ([va_Mod_vec 2; va_Mod_vec 1]) (va_wp_ShiftLeft128_1 a)
    (va_wpProof_ShiftLeft128_1 a))
//--
//-- High64ToLow

val va_code_High64ToLow : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code

val va_codegen_success_High64ToLow : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
  va_pbool

val va_lemma_High64ToLow : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
  src:va_operand_vec_opr -> a:poly
  -> Ghost (va_state & va_fuel)
  (requires (va_require_total va_b0 (va_code_High64ToLow dst src) va_s0 /\ va_is_dst_vec_opr dst
    va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ va_get_vec 0 va_s0 ==
    Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0 0 /\ Vale.Math.Poly2_s.degree a <= 127 /\
    va_eval_vec_opr va_s0 src == Vale.Math.Poly2.Bits_s.to_quad32 a))
  (ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
    va_eval_vec_opr va_sM dst == Vale.Math.Poly2.Bits_s.to_quad32 (Vale.Math.Poly2_s.div a
    (Vale.Math.Poly2_s.monomial 64)) /\ va_state_eq va_sM (va_update_ok va_sM
    (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_High64ToLow (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (a:poly) (va_s0:va_state)
  (va_k:(va_state -> unit -> Type0)) : Type0 =
  (va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ va_get_vec 0
    va_s0 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0 0 /\ Vale.Math.Poly2_s.degree a
    <= 127 /\ va_eval_vec_opr va_s0 src == Vale.Math.Poly2.Bits_s.to_quad32 a /\ (forall
    (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
    va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Math.Poly2.Bits_s.to_quad32
    (Vale.Math.Poly2_s.div a (Vale.Math.Poly2_s.monomial 64)) ==> va_k va_sM (())))

val va_wpProof_High64ToLow : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> a:poly ->
  va_s0:va_state -> va_k:(va_state -> unit -> Type0)
  -> Ghost (va_state & va_fuel & unit)
  (requires (va_t_require va_s0 /\ va_wp_High64ToLow dst src a va_s0 va_k))
  (ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_High64ToLow dst src) ([va_mod_vec_opr
    dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_High64ToLow (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (a:poly) : (va_quickCode
  unit (va_code_High64ToLow dst src)) =
  (va_QProc (va_code_High64ToLow dst src) ([va_mod_vec_opr dst]) (va_wp_High64ToLow dst src a)
    (va_wpProof_High64ToLow dst src a))
//--
//-- Low64ToHigh

val va_code_Low64ToHigh : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot va_code

val va_codegen_success_Low64ToHigh : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> Tot
  va_pbool

val va_lemma_Low64ToHigh : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
  src:va_operand_vec_opr -> a:poly
  -> Ghost (va_state & va_fuel)
  (requires (va_require_total va_b0 (va_code_Low64ToHigh dst src) va_s0 /\ va_is_dst_vec_opr dst
    va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ va_get_vec 0 va_s0 ==
    Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0 0 /\ Vale.Math.Poly2_s.degree a <= 127 /\
    va_eval_vec_opr va_s0 src == Vale.Math.Poly2.Bits_s.to_quad32 a))
  (ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
    va_eval_vec_opr va_sM dst == Vale.Math.Poly2.Bits_s.to_quad32 (Vale.Math.Poly2_s.mul
    (Vale.Math.Poly2_s.mod a (Vale.Math.Poly2_s.monomial 64)) (Vale.Math.Poly2_s.monomial 64)) /\
    va_state_eq va_sM (va_update_ok va_sM (va_update_operand_vec_opr dst va_sM va_s0))))
[@ va_qattr]
let va_wp_Low64ToHigh (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (a:poly) (va_s0:va_state)
  (va_k:(va_state -> unit -> Type0)) : Type0 =
  (va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src va_s0 /\ va_get_ok va_s0 /\ va_get_vec 0
    va_s0 == Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0 0 /\ Vale.Math.Poly2_s.degree a
    <= 127 /\ va_eval_vec_opr va_s0 src == Vale.Math.Poly2.Bits_s.to_quad32 a /\ (forall
    (va_x_dst:va_value_vec_opr) . let va_sM = va_upd_operand_vec_opr dst va_x_dst va_s0 in
    va_get_ok va_sM /\ va_eval_vec_opr va_sM dst == Vale.Math.Poly2.Bits_s.to_quad32
    (Vale.Math.Poly2_s.mul (Vale.Math.Poly2_s.mod a (Vale.Math.Poly2_s.monomial 64))
    (Vale.Math.Poly2_s.monomial 64)) ==> va_k va_sM (())))

val va_wpProof_Low64ToHigh : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> a:poly ->
  va_s0:va_state -> va_k:(va_state -> unit -> Type0)
  -> Ghost (va_state & va_fuel & unit)
  (requires (va_t_require va_s0 /\ va_wp_Low64ToHigh dst src a va_s0 va_k))
  (ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Low64ToHigh dst src) ([va_mod_vec_opr
    dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Low64ToHigh (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (a:poly) : (va_quickCode
  unit (va_code_Low64ToHigh dst src)) =
  (va_QProc (va_code_Low64ToHigh dst src) ([va_mod_vec_opr dst]) (va_wp_Low64ToHigh dst src a)
    (va_wpProof_Low64ToHigh dst src a))
//--
//-- ReduceMulRev128

val va_code_ReduceMulRev128 : va_dummy:unit -> Tot va_code

val va_codegen_success_ReduceMulRev128 : va_dummy:unit -> Tot va_pbool

val va_lemma_ReduceMulRev128 : va_b0:va_code -> va_s0:va_state -> a:poly -> b:poly
  -> Ghost (va_state & va_fuel)
  (requires (va_require_total va_b0 (va_code_ReduceMulRev128 ()) va_s0 /\ va_get_ok va_s0 /\
    Vale.Math.Poly2_s.degree a <= 127 /\ Vale.Math.Poly2_s.degree b <= 127 /\ va_get_vec 1 va_s0 ==
    Vale.Math.Poly2.Bits_s.to_quad32 (Vale.Math.Poly2_s.reverse a 127) /\ va_get_vec 2 va_s0 ==
    Vale.Math.Poly2.Bits_s.to_quad32 (Vale.Math.Poly2_s.reverse b 127)))
  (ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
    va_get_vec 1 va_sM == Vale.Math.Poly2.Bits_s.to_quad32 (Vale.Math.Poly2_s.reverse
    (Vale.AES.GF128_s.gf128_mul a b) 127) /\ va_state_eq va_sM (va_update_vec 6 va_sM
    (va_update_vec 5 va_sM (va_update_vec 4 va_sM (va_update_vec 3 va_sM (va_update_vec 2 va_sM
    (va_update_vec 1 va_sM (va_update_vec 0 va_sM (va_update_reg 10 va_sM (va_update_ok va_sM
    va_s0)))))))))))
[@ va_qattr]
let va_wp_ReduceMulRev128 (a:poly) (b:poly) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) :
  Type0 =
  (va_get_ok va_s0 /\ Vale.Math.Poly2_s.degree a <= 127 /\ Vale.Math.Poly2_s.degree b <= 127 /\
    va_get_vec 1 va_s0 == Vale.Math.Poly2.Bits_s.to_quad32 (Vale.Math.Poly2_s.reverse a 127) /\
    va_get_vec 2 va_s0 == Vale.Math.Poly2.Bits_s.to_quad32 (Vale.Math.Poly2_s.reverse b 127) /\
    (forall (va_x_r10:nat64) (va_x_v0:quad32) (va_x_v1:quad32) (va_x_v2:quad32) (va_x_v3:quad32)
    (va_x_v4:quad32) (va_x_v5:quad32) (va_x_v6:quad32) . let va_sM = va_upd_vec 6 va_x_v6
    (va_upd_vec 5 va_x_v5 (va_upd_vec 4 va_x_v4 (va_upd_vec 3 va_x_v3 (va_upd_vec 2 va_x_v2
    (va_upd_vec 1 va_x_v1 (va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 va_s0))))))) in va_get_ok
    va_sM /\ va_get_vec 1 va_sM == Vale.Math.Poly2.Bits_s.to_quad32 (Vale.Math.Poly2_s.reverse
    (Vale.AES.GF128_s.gf128_mul a b) 127) ==> va_k va_sM (())))

val va_wpProof_ReduceMulRev128 : a:poly -> b:poly -> va_s0:va_state -> va_k:(va_state -> unit ->
  Type0)
  -> Ghost (va_state & va_fuel & unit)
  (requires (va_t_require va_s0 /\ va_wp_ReduceMulRev128 a b va_s0 va_k))
  (ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_ReduceMulRev128 ()) ([va_Mod_vec 6;
    va_Mod_vec 5; va_Mod_vec 4; va_Mod_vec 3; va_Mod_vec 2; va_Mod_vec 1; va_Mod_vec 0; va_Mod_reg
    10]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_ReduceMulRev128 (a:poly) (b:poly) : (va_quickCode unit (va_code_ReduceMulRev128 ())) =
  (va_QProc (va_code_ReduceMulRev128 ()) ([va_Mod_vec 6; va_Mod_vec 5; va_Mod_vec 4; va_Mod_vec 3;
    va_Mod_vec 2; va_Mod_vec 1; va_Mod_vec 0; va_Mod_reg 10]) (va_wp_ReduceMulRev128 a b)
    (va_wpProof_ReduceMulRev128 a b))
//--
//-- Gf128MulRev128

val va_code_Gf128MulRev128 : va_dummy:unit -> Tot va_code

val va_codegen_success_Gf128MulRev128 : va_dummy:unit -> Tot va_pbool

val va_lemma_Gf128MulRev128 : va_b0:va_code -> va_s0:va_state
  -> Ghost (va_state & va_fuel)
  (requires (va_require_total va_b0 (va_code_Gf128MulRev128 ()) va_s0 /\ va_get_ok va_s0))
  (ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
    (let (a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_get_vec 1 va_s0) in let
    (b:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_get_vec 2 va_s0) in
    Vale.Math.Poly2.Bits_s.of_quad32 (va_get_vec 1 va_sM) == Vale.AES.GF128.gf128_mul_rev a b) /\
    va_state_eq va_sM (va_update_vec 6 va_sM (va_update_vec 5 va_sM (va_update_vec 4 va_sM
    (va_update_vec 3 va_sM (va_update_vec 2 va_sM (va_update_vec 1 va_sM (va_update_vec 0 va_sM
    (va_update_reg 10 va_sM (va_update_ok va_sM va_s0)))))))))))
[@ va_qattr]
let va_wp_Gf128MulRev128 (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
  (va_get_ok va_s0 /\ (forall (va_x_r10:nat64) (va_x_v0:quad32) (va_x_v1:quad32) (va_x_v2:quad32)
    (va_x_v3:quad32) (va_x_v4:quad32) (va_x_v5:quad32) (va_x_v6:quad32) . let va_sM = va_upd_vec 6
    va_x_v6 (va_upd_vec 5 va_x_v5 (va_upd_vec 4 va_x_v4 (va_upd_vec 3 va_x_v3 (va_upd_vec 2 va_x_v2
    (va_upd_vec 1 va_x_v1 (va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 va_s0))))))) in va_get_ok
    va_sM /\ (let (a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_get_vec 1
    va_s0) in let (b:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_get_vec 2
    va_s0) in Vale.Math.Poly2.Bits_s.of_quad32 (va_get_vec 1 va_sM) == Vale.AES.GF128.gf128_mul_rev
    a b) ==> va_k va_sM (())))

val va_wpProof_Gf128MulRev128 : va_s0:va_state -> va_k:(va_state -> unit -> Type0)
  -> Ghost (va_state & va_fuel & unit)
  (requires (va_t_require va_s0 /\ va_wp_Gf128MulRev128 va_s0 va_k))
  (ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Gf128MulRev128 ()) ([va_Mod_vec 6;
    va_Mod_vec 5; va_Mod_vec 4; va_Mod_vec 3; va_Mod_vec 2; va_Mod_vec 1; va_Mod_vec 0; va_Mod_reg
    10]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
val va_quick_Gf128MulRev128: Prims.unit -> (va_quickCode unit (va_code_Gf128MulRev128 ()))
_: Prims.unit
  -> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
      (Vale.AES.PPC64LE.GF128_Mul.va_code_Gf128MulRev128 ())