val va_quick_VPolyMulLow (dst src1 src2: va_operand_vec_opr)
    : (va_quickCode unit (va_code_VPolyMulLow dst src1 src2))
val va_quick_VPolyMulLow (dst src1 src2: va_operand_vec_opr)
    : (va_quickCode unit (va_code_VPolyMulLow dst src1 src2))
let va_quick_VPolyMulLow (dst:va_operand_vec_opr) (src1:va_operand_vec_opr)
  (src2:va_operand_vec_opr) : (va_quickCode unit (va_code_VPolyMulLow dst src1 src2)) =
  (va_QProc (va_code_VPolyMulLow dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_VPolyMulLow dst src1
    src2) (va_wpProof_VPolyMulLow dst src1 src2))
module Vale.AES.PPC64LE.PolyOps
open Vale.Def.Types_s
open Vale.Arch.Types
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.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.GHash_BE
//-- VPolyAdd

val va_code_VPolyAdd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
  -> Tot va_code

val va_codegen_success_VPolyAdd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
  src2:va_operand_vec_opr -> Tot va_pbool

val va_lemma_VPolyAdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
  src1:va_operand_vec_opr -> src2:va_operand_vec_opr
  -> Ghost (va_state & va_fuel)
  (requires (va_require_total va_b0 (va_code_VPolyAdd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
    va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 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 (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_vec_opr va_s0
    src1) in let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_vec_opr
    va_s0 src2) in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_vec_opr va_sM dst) ==
    Vale.Math.Poly2_s.add a1 a2) /\ 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_VPolyAdd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
  (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
  (va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
    va_get_ok va_s0 /\ (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 /\ (let (a1:Vale.Math.Poly2_s.poly) =
    Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_vec_opr va_s0 src1) in let
    (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_vec_opr va_s0 src2) in
    Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_vec_opr va_sM dst) == Vale.Math.Poly2_s.add a1 a2)
    ==> va_k va_sM (())))

val va_wpProof_VPolyAdd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
  src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
  -> Ghost (va_state & va_fuel & unit)
  (requires (va_t_require va_s0 /\ va_wp_VPolyAdd dst src1 src2 va_s0 va_k))
  (ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPolyAdd dst src1 src2)
    ([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPolyAdd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
  : (va_quickCode unit (va_code_VPolyAdd dst src1 src2)) =
  (va_QProc (va_code_VPolyAdd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_VPolyAdd dst src1 src2)
    (va_wpProof_VPolyAdd dst src1 src2))
//--
//-- VPolyAnd

val va_code_VPolyAnd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
  -> Tot va_code

val va_codegen_success_VPolyAnd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
  src2:va_operand_vec_opr -> Tot va_pbool

val va_lemma_VPolyAnd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
  src1:va_operand_vec_opr -> src2:va_operand_vec_opr
  -> Ghost (va_state & va_fuel)
  (requires (va_require_total va_b0 (va_code_VPolyAnd dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
    va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 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 (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_vec_opr va_s0
    src1) in let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_vec_opr
    va_s0 src2) in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_vec_opr va_sM dst) ==
    Vale.Math.Poly2.poly_and a1 a2) /\ 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_VPolyAnd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
  (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
  (va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
    va_get_ok va_s0 /\ (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 /\ (let (a1:Vale.Math.Poly2_s.poly) =
    Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_vec_opr va_s0 src1) in let
    (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_vec_opr va_s0 src2) in
    Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_vec_opr va_sM dst) == Vale.Math.Poly2.poly_and a1 a2)
    ==> va_k va_sM (())))

val va_wpProof_VPolyAnd : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
  src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
  -> Ghost (va_state & va_fuel & unit)
  (requires (va_t_require va_s0 /\ va_wp_VPolyAnd dst src1 src2 va_s0 va_k))
  (ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPolyAnd dst src1 src2)
    ([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPolyAnd (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
  : (va_quickCode unit (va_code_VPolyAnd dst src1 src2)) =
  (va_QProc (va_code_VPolyAnd dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_VPolyAnd dst src1 src2)
    (va_wpProof_VPolyAnd dst src1 src2))
//--
//-- VSwap

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

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

val va_lemma_VSwap : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
  src:va_operand_vec_opr
  -> Ghost (va_state & va_fuel)
  (requires (va_require_total va_b0 (va_code_VSwap 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))
  (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_eval_vec_opr va_s0 src)
    in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_vec_opr va_sM dst) == Vale.Math.Poly2.swap a 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_VSwap (dst:va_operand_vec_opr) (src:va_operand_vec_opr) (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 /\ (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 /\ (let (a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
    (va_eval_vec_opr va_s0 src) in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_vec_opr va_sM dst) ==
    Vale.Math.Poly2.swap a 64) ==> va_k va_sM (())))

val va_wpProof_VSwap : dst:va_operand_vec_opr -> src:va_operand_vec_opr -> va_s0:va_state ->
  va_k:(va_state -> unit -> Type0)
  -> Ghost (va_state & va_fuel & unit)
  (requires (va_t_require va_s0 /\ va_wp_VSwap dst src va_s0 va_k))
  (ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VSwap 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_VSwap (dst:va_operand_vec_opr) (src:va_operand_vec_opr) : (va_quickCode unit
  (va_code_VSwap dst src)) =
  (va_QProc (va_code_VSwap dst src) ([va_mod_vec_opr dst]) (va_wp_VSwap dst src) (va_wpProof_VSwap
    dst src))
//--
//-- VPolyMul

val va_code_VPolyMul : dst:va_operand_vec_opr -> src1:va_operand_vec_opr -> src2:va_operand_vec_opr
  -> Tot va_code

val va_codegen_success_VPolyMul : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
  src2:va_operand_vec_opr -> Tot va_pbool

val va_lemma_VPolyMul : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
  src1:va_operand_vec_opr -> src2:va_operand_vec_opr
  -> Ghost (va_state & va_fuel)
  (requires (va_require_total va_b0 (va_code_VPolyMul dst src1 src2) va_s0 /\ va_is_dst_vec_opr dst
    va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 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 (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_vec_opr va_s0
    src1) in let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_vec_opr
    va_s0 src2) in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_vec_opr va_sM dst) ==
    Vale.Math.Poly2_s.add (Vale.Math.Poly2_s.mul (Vale.Math.Poly2.mask a1 64) (Vale.Math.Poly2.mask
    a2 64)) (Vale.Math.Poly2_s.mul (Vale.Math.Poly2_s.shift a1 (-64)) (Vale.Math.Poly2_s.shift a2
    (-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_VPolyMul (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
  (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
  (va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
    va_get_ok va_s0 /\ (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 /\ (let (a1:Vale.Math.Poly2_s.poly) =
    Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_vec_opr va_s0 src1) in let
    (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_vec_opr va_s0 src2) in
    Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_vec_opr va_sM dst) == Vale.Math.Poly2_s.add
    (Vale.Math.Poly2_s.mul (Vale.Math.Poly2.mask a1 64) (Vale.Math.Poly2.mask a2 64))
    (Vale.Math.Poly2_s.mul (Vale.Math.Poly2_s.shift a1 (-64)) (Vale.Math.Poly2_s.shift a2 (-64))))
    ==> va_k va_sM (())))

val va_wpProof_VPolyMul : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
  src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
  -> Ghost (va_state & va_fuel & unit)
  (requires (va_t_require va_s0 /\ va_wp_VPolyMul dst src1 src2 va_s0 va_k))
  (ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPolyMul dst src1 src2)
    ([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPolyMul (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
  : (va_quickCode unit (va_code_VPolyMul dst src1 src2)) =
  (va_QProc (va_code_VPolyMul dst src1 src2) ([va_mod_vec_opr dst]) (va_wp_VPolyMul dst src1 src2)
    (va_wpProof_VPolyMul dst src1 src2))
//--
//-- VPolyMulLow

val va_code_VPolyMulLow : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
  src2:va_operand_vec_opr -> Tot va_code

val va_codegen_success_VPolyMulLow : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
  src2:va_operand_vec_opr -> Tot va_pbool

val va_lemma_VPolyMulLow : va_b0:va_code -> va_s0:va_state -> dst:va_operand_vec_opr ->
  src1:va_operand_vec_opr -> src2:va_operand_vec_opr
  -> Ghost (va_state & va_fuel)
  (requires (va_require_total va_b0 (va_code_VPolyMulLow dst src1 src2) va_s0 /\ va_is_dst_vec_opr
    dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\ va_get_ok va_s0 /\
    (let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_vec_opr va_s0
    src1) in let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_vec_opr
    va_s0 src2) in l_or (Vale.Math.Poly2_s.shift a1 (-64) == zero) (Vale.Math.Poly2_s.shift a2
    (-64) == zero))))
  (ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
    (let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_vec_opr va_s0
    src1) in let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_vec_opr
    va_s0 src2) in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_vec_opr va_sM dst) ==
    Vale.Math.Poly2_s.mul (Vale.Math.Poly2.mask a1 64) (Vale.Math.Poly2.mask a2 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_VPolyMulLow (dst:va_operand_vec_opr) (src1:va_operand_vec_opr) (src2:va_operand_vec_opr)
  (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
  (va_is_dst_vec_opr dst va_s0 /\ va_is_src_vec_opr src1 va_s0 /\ va_is_src_vec_opr src2 va_s0 /\
    va_get_ok va_s0 /\ (let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
    (va_eval_vec_opr va_s0 src1) in let (a2:Vale.Math.Poly2_s.poly) =
    Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_vec_opr va_s0 src2) in l_or (Vale.Math.Poly2_s.shift
    a1 (-64) == zero) (Vale.Math.Poly2_s.shift a2 (-64) == zero)) /\ (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 /\ (let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32
    (va_eval_vec_opr va_s0 src1) in let (a2:Vale.Math.Poly2_s.poly) =
    Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_vec_opr va_s0 src2) in
    Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_vec_opr va_sM dst) == Vale.Math.Poly2_s.mul
    (Vale.Math.Poly2.mask a1 64) (Vale.Math.Poly2.mask a2 64)) ==> va_k va_sM (())))

val va_wpProof_VPolyMulLow : dst:va_operand_vec_opr -> src1:va_operand_vec_opr ->
  src2:va_operand_vec_opr -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
  -> Ghost (va_state & va_fuel & unit)
  (requires (va_t_require va_s0 /\ va_wp_VPolyMulLow dst src1 src2 va_s0 va_k))
  (ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPolyMulLow dst src1 src2)
    ([va_mod_vec_opr dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
/
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.Types_s.fst.checked Vale.Arch.Types.fsti.checked Vale.AES.GHash_BE.fsti.checked prims.fst.checked FStar.Pervasives.Native.fst.checked FStar.Pervasives.fsti.checked
Vale.AES.PPC64LE.PolyOps.fsti

    dst: Vale.PPC64LE.Decls.va_operand_vec_opr ->
    src1: Vale.PPC64LE.Decls.va_operand_vec_opr ->
    src2: Vale.PPC64LE.Decls.va_operand_vec_opr
  -> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
      (Vale.AES.PPC64LE.PolyOps.va_code_VPolyMulLow dst src1 src2)
Vale.PPC64LE.Decls.va_operand_vec_opr Vale.PPC64LE.QuickCode.va_QProc Prims.unit Vale.AES.PPC64LE.PolyOps.va_code_VPolyMulLow Prims.Cons Vale.PPC64LE.QuickCode.mod_t Vale.PPC64LE.QuickCode.va_mod_vec_opr Prims.Nil Vale.AES.PPC64LE.PolyOps.va_wp_VPolyMulLow Vale.AES.PPC64LE.PolyOps.va_wpProof_VPolyMulLow Vale.PPC64LE.QuickCode.va_quickCode
let va_quick_VPolyMulLow (dst src1 src2: va_operand_vec_opr)
    : (va_quickCode unit (va_code_VPolyMulLow dst src1 src2)) =
  
(va_QProc (va_code_VPolyMulLow dst src1 src2)
    ([va_mod_vec_opr dst])
    (va_wp_VPolyMulLow dst src1 src2)
    (va_wpProof_VPolyMulLow dst src1 src2))